@vscode/chat-lib 0.3.1-2 → 0.3.1-21

package/dist/src/_internal/extension/inlineEdits/node/nextEditProvider.js

@@ -47,17 +47,20 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NextEditFetchRequest = exports.NextEditProvider = void 0;
+const path_1 = require("path");
 const configurationService_1 = require("../../../platform/configuration/common/configurationService");
 const edit_1 = require("../../../platform/inlineEdits/common/dataTypes/edit");
 const rootedLineEdit_1 = require("../../../platform/inlineEdits/common/dataTypes/rootedLineEdit");
+const inlineEditLogContext_1 = require("../../../platform/inlineEdits/common/inlineEditLogContext");
 const statelessNextEditProvider_1 = require("../../../platform/inlineEdits/common/statelessNextEditProvider");
 const observable_1 = require("../../../platform/inlineEdits/common/utils/observable");
 const logService_1 = require("../../../platform/log/common/logService");
+const capturingToken_1 = require("../../../platform/requestLogger/common/capturingToken");
+const requestLogger_1 = require("../../../platform/requestLogger/node/requestLogger");
 const snippyService_1 = require("../../../platform/snippy/common/snippyService");
 const nullExperimentationService_1 = require("../../../platform/telemetry/common/nullExperimentationService");
 const errors = __importStar(require("../../../util/common/errors"));
 const result_1 = require("../../../util/common/result");
-const tracing_1 = require("../../../util/common/tracing");
 const assert_1 = require("../../../util/vs/base/common/assert");
 const async_1 = require("../../../util/vs/base/common/async");
 const cache_1 = require("../../../util/vs/base/common/cache");
@@ -69,11 +72,40 @@ const types_1 = require("../../../util/vs/base/common/types");
 const uuid_1 = require("../../../util/vs/base/common/uuid");
 const lineEdit_1 = require("../../../util/vs/editor/common/core/edits/lineEdit");
 const stringEdit_1 = require("../../../util/vs/editor/common/core/edits/stringEdit");
+const position_1 = require("../../../util/vs/editor/common/core/position");
 const offsetRange_1 = require("../../../util/vs/editor/common/core/ranges/offsetRange");
+const abstractText_1 = require("../../../util/vs/editor/common/core/text/abstractText");
 const editRebase_1 = require("../common/editRebase");
 const rejectionCollector_1 = require("../common/rejectionCollector");
 const nextEditCache_1 = require("./nextEditCache");
 const nextEditResult_1 = require("./nextEditResult");
+/**
+ * Computes a reduced window range that encompasses both the original window (shrunk by one line
+ * on each end) and the full line where the cursor is located.
+ *
+ * This ensures the cache invalidation window always includes the cursor's line while trimming
+ * the edges of the original window.
+ */
+function computeReducedWindow(window, activeDocSelection, documentBeforeEdits) {
+    if (!activeDocSelection) {
+        return window;
+    }
+    const cursorOffset = activeDocSelection.endExclusive;
+    const t = documentBeforeEdits.getTransformer();
+    const cursorPosition = t.getPosition(cursorOffset);
+    const lineOffset = t.getOffset(cursorPosition.with(undefined, 1));
+    const lineEndOffset = t.getOffset(cursorPosition.with(undefined, t.getLineLength(cursorPosition.lineNumber) + 1));
+    const reducedOffset = t.getOffset(t.getPosition(window.start).delta(1));
+    const reducedEndPosition = t.getPosition(window.endExclusive).delta(-2);
+    const reducedEndOffset = t.getOffset(reducedEndPosition.column > 1 ? reducedEndPosition.with(undefined, t.getLineLength(reducedEndPosition.lineNumber) + 1) : reducedEndPosition);
+    return new offsetRange_1.OffsetRange(Math.min(reducedOffset, lineOffset), Math.max(reducedEndOffset, lineEndOffset));
+}
+function convertLineEditToEdit(nextLineEdit, projectedDocuments, docId) {
+    const doc = projectedDocuments.find(d => d.nextEditDoc.id === docId);
+    const rootedLineEdit = new rootedLineEdit_1.RootedLineEdit(doc.documentAfterEdits, nextLineEdit);
+    const suggestedEdit = rootedLineEdit.toEdit();
+    return suggestedEdit;
+}
 let NextEditProvider = class NextEditProvider extends lifecycle_1.Disposable {
     get lastRejectionTime() {
         return this._lastRejectionTime;
@@ -81,7 +113,7 @@ let NextEditProvider = class NextEditProvider extends lifecycle_1.Disposable {
     get lastTriggerTime() {
         return this._lastTriggerTime;
     }
-    constructor(_workspace, _statelessNextEditProvider, _historyContextProvider, _xtabHistoryTracker, _debugRecorder, _configService, _snippyService, _logService, _expService) {
+    constructor(_workspace, _statelessNextEditProvider, _historyContextProvider, _xtabHistoryTracker, _debugRecorder, _configService, _snippyService, _logService, _expService, _requestLogger) {
         super();
         this._workspace = _workspace;
         this._statelessNextEditProvider = _statelessNextEditProvider;
@@ -92,14 +124,23 @@ let NextEditProvider = class NextEditProvider extends lifecycle_1.Disposable {
         this._snippyService = _snippyService;
         this._logService = _logService;
         this._expService = _expService;
+        this._requestLogger = _requestLogger;
         this.ID = this._statelessNextEditProvider.ID;
-        this._rejectionCollector = this._register(new rejectionCollector_1.RejectionCollector(this._workspace, s => this._logService.trace(s)));
+        this._rejectionCollector = this._register(new rejectionCollector_1.RejectionCollector(this._workspace, this._logService));
         this._pendingStatelessNextEditRequest = null;
+        /**
+         * Tracks a speculative request for the post-edit document state.
+         * When a suggestion is shown, we speculatively fetch the next edit as if the user had already accepted.
+         * This allows reusing the in-flight request when the user actually accepts the suggestion.
+         */
+        this._speculativePendingRequest = null;
         this._lastShownTime = 0;
+        /** The requestId of the last shown suggestion. We store only the requestId (not the object) to avoid preventing garbage collection. */
+        this._lastShownSuggestionId = undefined;
         this._lastRejectionTime = 0;
         this._lastTriggerTime = 0;
         this._shouldExpandEditWindow = false;
-        this._tracer = (0, tracing_1.createTracer)(['NES', 'NextEditProvider'], (s) => this._logService.trace(s));
+        this._logger = this._logService.createSubLogger(['NES', 'NextEditProvider']);
         this._nextEditCache = new nextEditCache_1.NextEditCache(this._workspace, this._logService, this._configService, this._expService);
         (0, observable_2.mapObservableArrayCached)(this, this._workspace.openDocuments, (doc, store) => {
             store.add((0, observable_2.runOnChange)(doc.value, (value) => {
@@ -121,16 +162,15 @@ let NextEditProvider = class NextEditProvider extends lifecycle_1.Disposable {
         const now = Date.now();
         this._lastTriggerTime = now;
         const sw = new stopwatch_1.StopWatch();
-        const tracer = this._tracer.sub(context.requestUuid.substring(4, 8), {
-            extraLog: (msg) => {
-                logContext.trace(`[${Math.floor(sw.elapsed()).toString().padStart(4, ' ')}ms] ${msg}`);
-            }
-        });
+        const logger = this._logger.createSubLogger(context.requestUuid.substring(4, 8))
+            .withExtraTarget(logService_1.LogTarget.fromCallback((_level, msg) => {
+            logContext.trace(`[${Math.floor(sw.elapsed()).toString().padStart(4, ' ')}ms] ${msg}`);
+        }));
         const shouldExpandEditWindow = this._shouldExpandEditWindow;
         logContext.setStatelessNextEditProviderId(this._statelessNextEditProvider.ID);
         let result;
         try {
-            result = await this._getNextEditCanThrow(docId, context, now, shouldExpandEditWindow, tracer, logContext, cancellationToken, telemetryBuilder);
+            result = await this._getNextEditCanThrow(docId, context, now, shouldExpandEditWindow, logger, logContext, cancellationToken, telemetryBuilder);
         }
         catch (error) {
             logContext.setError(error);
@@ -143,20 +183,20 @@ let NextEditProvider = class NextEditProvider extends lifecycle_1.Disposable {
         this._lastNextEditResult = result;
         return result;
     }
-    async _getNextEditCanThrow(docId, context, triggerTime, shouldExpandEditWindow, parentTracer, logContext, cancellationToken, telemetryBuilder) {
-        const tracer = parentTracer.sub('_getNextEdit');
-        tracer.trace(`invoked with trigger id = ${context.changeHint?.data}`);
+    async _getNextEditCanThrow(docId, context, triggerTime, shouldExpandEditWindow, parentLogger, logContext, cancellationToken, telemetryBuilder) {
+        const logger = parentLogger.createSubLogger('_getNextEdit');
+        logger.trace(`invoked with trigger id = ${context.changeHint === undefined ? 'undefined' : `uuid = ${context.changeHint.data.uuid}, reason = ${context.changeHint.data.reason}`}`);
         const doc = this._workspace.getDocument(docId);
         if (!doc) {
-            tracer.throws(`Document "${docId.baseName}" not found`);
+            logger.trace(`Document "${docId.baseName}" not found`);
             throw new errors_1.BugIndicatingError(`Document "${docId.baseName}" not found`);
         }
         const documentAtInvocationTime = doc.value.get();
         const selections = doc.selection.get();
         const nesConfigs = this.determineNesConfigs(telemetryBuilder, logContext);
-        const cachedEdit = this._nextEditCache.lookupNextEdit(docId, documentAtInvocationTime, selections, nesConfigs);
+        const cachedEdit = this._nextEditCache.lookupNextEdit(docId, documentAtInvocationTime, selections);
         if (cachedEdit?.rejected) {
-            tracer.trace('cached edit was previously rejected');
+            logger.trace('cached edit was previously rejected');
             telemetryBuilder.setStatus('previouslyRejectedCache');
             telemetryBuilder.setWasPreviouslyRejected();
             const nextEditResult = new nextEditResult_1.NextEditResult(logContext.requestId, cachedEdit.source, undefined);
@@ -170,7 +210,7 @@ let NextEditProvider = class NextEditProvider extends lifecycle_1.Disposable {
         let isRebasedCachedEdit = false;
         let isSubsequentCachedEdit = false;
         if (cachedEdit) {
-            tracer.trace('using cached edit');
+            logger.trace('using cached edit');
             const actualEdit = cachedEdit.rebasedEdit || cachedEdit.edit;
             if (actualEdit) {
                 edit = { actualEdit, isFromCursorJump: cachedEdit.isFromCursorJump };
@@ -187,21 +227,21 @@ let NextEditProvider = class NextEditProvider extends lifecycle_1.Disposable {
             logContext.recordingBookmark = req.log.recordingBookmark;
         }
         else {
-            tracer.trace(`fetching next edit with shouldExpandEditWindow=${shouldExpandEditWindow}`);
+            logger.trace(`fetching next edit with shouldExpandEditWindow=${shouldExpandEditWindow}`);
             const providerRequestStartDateTime = (this._configService.getExperimentBasedConfig(configurationService_1.ConfigKey.TeamInternal.InlineEditsDebounceUseCoreRequestTime, this._expService)
                 ? (context.requestIssuedDateTime ?? undefined)
                 : undefined);
             req = new NextEditFetchRequest(context.requestUuid, logContext, providerRequestStartDateTime);
             telemetryBuilder.setHeaderRequestId(req.headerRequestId);
             const startVersion = doc.value.get();
-            tracer.trace('awaiting firstEdit promise');
-            const result = await this.fetchNextEdit(req, doc, nesConfigs, shouldExpandEditWindow, tracer, telemetryBuilder, cancellationToken);
-            tracer.trace('resolved firstEdit promise');
+            logger.trace('awaiting firstEdit promise');
+            const result = await this.fetchNextEdit(req, doc, nesConfigs, shouldExpandEditWindow, logger, telemetryBuilder, cancellationToken);
+            logger.trace('resolved firstEdit promise');
             const latency = `First edit latency: ${Date.now() - this._lastTriggerTime} ms`;
             logContext.addLog(latency);
-            tracer.trace(latency);
+            logger.trace(latency);
             if (result.isError()) {
-                tracer.trace(`failed to fetch next edit ${result.err.toString()}`);
+                logger.trace(`failed to fetch next edit ${result.err.toString()}`);
                 telemetryBuilder.setStatus(`noEdit:${result.err.kind}`);
                 error = result.err;
             }
@@ -211,18 +251,18 @@ let NextEditProvider = class NextEditProvider extends lifecycle_1.Disposable {
                 currentDocument = targetDoc.value.get();
                 const docDidChange = targetDocumentId === doc.id && startVersion.value !== currentDocument.value;
                 if (docDidChange) {
-                    tracer.trace('document changed while fetching next edit');
+                    logger.trace('document changed while fetching next edit');
                     telemetryBuilder.setStatus('docChanged');
                     logContext.setIsSkipped();
                 }
                 else {
                     const suggestedNextEdit = result.val.rebasedEdit || result.val.edit;
                     if (!suggestedNextEdit) {
-                        tracer.trace('empty edits');
+                        logger.trace('empty edits');
                         telemetryBuilder.setStatus('emptyEdits');
                     }
                     else {
-                        tracer.trace('fetch succeeded');
+                        logger.trace('fetch succeeded');
                         logContext.setResponseResults([suggestedNextEdit]); // TODO: other streamed edits?
                         edit = { actualEdit: suggestedNextEdit, isFromCursorJump: result.val.isFromCursorJump };
                     }
@@ -230,7 +270,7 @@ let NextEditProvider = class NextEditProvider extends lifecycle_1.Disposable {
             }
         }
         if (error instanceof statelessNextEditProvider_1.NoNextEditReason.FetchFailure || error instanceof statelessNextEditProvider_1.NoNextEditReason.Unexpected) {
-            tracer.throws('has throwing error', error.error);
+            logger.trace(`has throwing error: ${error.error}`);
             throw error.error;
         }
         else if (error instanceof statelessNextEditProvider_1.NoNextEditReason.NoSuggestions) {
@@ -244,17 +284,17 @@ let NextEditProvider = class NextEditProvider extends lifecycle_1.Disposable {
         }
         const emptyResult = new nextEditResult_1.NextEditResult(logContext.requestId, req, undefined);
         if (!edit) {
-            tracer.returns('had no edit');
+            logger.trace('had no edit');
             // telemetry builder status must've been set earlier
             return emptyResult;
         }
         if (cancellationToken.isCancellationRequested) {
-            tracer.returns('cancelled');
+            logger.trace('cancelled');
             telemetryBuilder.setStatus(`noEdit:gotCancelled`);
             return emptyResult;
         }
-        if (this._rejectionCollector.isRejected(targetDocumentId, edit.actualEdit) || currentDocument && this._nextEditCache.isRejectedNextEdit(targetDocumentId, currentDocument, edit.actualEdit, nesConfigs)) {
-            tracer.returns('edit was previously rejected');
+        if (this._rejectionCollector.isRejected(targetDocumentId, edit.actualEdit) || currentDocument && this._nextEditCache.isRejectedNextEdit(targetDocumentId, currentDocument, edit.actualEdit)) {
+            logger.trace('edit was previously rejected');
             telemetryBuilder.setStatus('previouslyRejected');
             telemetryBuilder.setWasPreviouslyRejected();
             return emptyResult;
@@ -265,16 +305,16 @@ let NextEditProvider = class NextEditProvider extends lifecycle_1.Disposable {
         const showRangePreference = this._statelessNextEditProvider.showNextEditPreference ?? "aroundEdit" /* ShowNextEditPreference.AroundEdit */;
         const nextEditResult = new nextEditResult_1.NextEditResult(logContext.requestId, req, { edit: edit.actualEdit, isFromCursorJump: edit.isFromCursorJump, showRangePreference, documentBeforeEdits: currentDocument, targetDocumentId });
         telemetryBuilder.setHasNextEdit(true);
-        const delay = this.computeMinimumResponseDelay({ triggerTime, isRebasedCachedEdit, isSubsequentCachedEdit, enforceCacheDelay: context.enforceCacheDelay }, tracer);
+        const delay = this.computeMinimumResponseDelay({ triggerTime, isRebasedCachedEdit, isSubsequentCachedEdit, enforceCacheDelay: context.enforceCacheDelay }, logger);
         if (delay > 0) {
             await (0, async_1.timeout)(delay);
             if (cancellationToken.isCancellationRequested) {
-                tracer.returns('cancelled');
+                logger.trace('cancelled');
                 telemetryBuilder.setStatus(`noEdit:gotCancelled`);
                 return emptyResult;
             }
         }
-        tracer.returns('returning next edit result');
+        logger.trace('returning next edit result');
         return nextEditResult;
     }
     determineNesConfigs(telemetryBuilder, logContext) {
@@ -299,9 +339,9 @@ let NextEditProvider = class NextEditProvider extends lifecycle_1.Disposable {
             documentAfterEdits: nextEditDoc.documentAfterEdits,
         };
     }
-    async fetchNextEdit(req, doc, nesConfigs, shouldExpandEditWindow, parentTracer, telemetryBuilder, cancellationToken) {
+    async fetchNextEdit(req, doc, nesConfigs, shouldExpandEditWindow, parentLogger, telemetryBuilder, cancellationToken) {
         const curDocId = doc.id;
-        const tracer = parentTracer.sub('fetchNextEdit');
+        const logger = parentLogger.createSubLogger('fetchNextEdit');
         const historyContext = this._historyContextProvider.getHistoryContext(curDocId);
         if (!historyContext) {
             return result_1.Result.error(new statelessNextEditProvider_1.NoNextEditReason.Unexpected(new Error('DocumentMissingInHistoryContext')));
@@ -310,45 +350,60 @@ let NextEditProvider = class NextEditProvider extends lifecycle_1.Disposable {
         const selectionAtInvocationTime = doc.selection.get();
         const logContext = req.log;
         logContext.setRecentEdit(historyContext);
+        // Check if we can reuse the regular pending request
         const pendingRequestStillCurrent = documentAtInvocationTime.value === this._pendingStatelessNextEditRequest?.documentBeforeEdits.value;
         const existingNextEditRequest = (pendingRequestStillCurrent || nesConfigs.isAsyncCompletions) && !this._pendingStatelessNextEditRequest?.cancellationTokenSource.token.isCancellationRequested
             && this._pendingStatelessNextEditRequest || undefined;
-        if (existingNextEditRequest) {
+        // Check if we can reuse the speculative pending request (from when a suggestion was shown)
+        const speculativeRequestMatches = this._speculativePendingRequest?.postEditContent === documentAtInvocationTime.value
+            && !this._speculativePendingRequest.request.cancellationTokenSource.token.isCancellationRequested;
+        const speculativeRequest = speculativeRequestMatches ? this._speculativePendingRequest?.request : undefined;
+        // Prefer speculative request if it matches (it was specifically created for this post-edit state)
+        const requestToReuse = speculativeRequest ?? existingNextEditRequest;
+        if (requestToReuse) {
             // Nice! No need to make another request, we can reuse the result from a pending request.
-            const nextEditResult = await this._joinNextEditRequest(existingNextEditRequest, telemetryBuilder, logContext, cancellationToken);
-            if (pendingRequestStillCurrent) {
+            if (speculativeRequest) {
+                logger.trace(`reusing speculative pending request (opportunityId=${speculativeRequest.opportunityId}, headerRequestId=${speculativeRequest.headerRequestId})`);
+                // Clear the speculative request since we're using it
+                this._speculativePendingRequest = null;
+            }
+            const nextEditResult = await this._joinNextEditRequest(requestToReuse, telemetryBuilder, logContext, cancellationToken);
+            const requestStillCurrent = speculativeRequest
+                ? speculativeRequestMatches // For speculative, we already checked it matches
+                : pendingRequestStillCurrent;
+            if (requestStillCurrent) {
                 telemetryBuilder.setStatelessNextEditTelemetry(nextEditResult.telemetry);
-                return nextEditResult.nextEdit.isError() ? nextEditResult.nextEdit : existingNextEditRequest.firstEdit.p;
+                return nextEditResult.nextEdit.isError() ? nextEditResult.nextEdit : requestToReuse.firstEdit.p;
             }
             else {
                 // Needs rebasing.
-                const cacheResult = await existingNextEditRequest.firstEdit.p;
+                const cacheResult = await requestToReuse.firstEdit.p;
                 if (cacheResult.isOk() && cacheResult.val.edit) {
-                    const rebasedCachedEdit = this._nextEditCache.tryRebaseCacheEntry(cacheResult.val, documentAtInvocationTime, selectionAtInvocationTime, nesConfigs);
+                    const rebasedCachedEdit = this._nextEditCache.tryRebaseCacheEntry(cacheResult.val, documentAtInvocationTime, selectionAtInvocationTime);
                     if (rebasedCachedEdit) {
                         telemetryBuilder.setStatelessNextEditTelemetry(nextEditResult.telemetry);
                         return result_1.Result.ok(rebasedCachedEdit);
                     }
                 }
                 if (cancellationToken.isCancellationRequested) {
-                    tracer.trace('document changed after rebase failed');
+                    logger.trace('document changed after rebase failed');
                     telemetryBuilder.setStatelessNextEditTelemetry(nextEditResult.telemetry);
                     return result_1.Result.error(new statelessNextEditProvider_1.NoNextEditReason.GotCancelled('afterFailedRebase'));
                 }
                 // Rebase failed (or result had error). Check if there is a new pending request. Otherwise continue with a new request below.
-                const pendingRequestStillCurrent = documentAtInvocationTime.value === this._pendingStatelessNextEditRequest?.documentBeforeEdits.value;
-                const existingNextEditRequest2 = pendingRequestStillCurrent && !this._pendingStatelessNextEditRequest?.cancellationTokenSource.token.isCancellationRequested
+                const pendingRequestStillCurrent2 = documentAtInvocationTime.value === this._pendingStatelessNextEditRequest?.documentBeforeEdits.value;
+                const existingNextEditRequest2 = pendingRequestStillCurrent2 && !this._pendingStatelessNextEditRequest?.cancellationTokenSource.token.isCancellationRequested
                     && this._pendingStatelessNextEditRequest || undefined;
                 if (existingNextEditRequest2) {
-                    tracer.trace('reusing 2nd existing next edit request after rebase failed');
-                    const nextEditResult = await this._joinNextEditRequest(existingNextEditRequest2, telemetryBuilder, logContext, cancellationToken);
-                    telemetryBuilder.setStatelessNextEditTelemetry(nextEditResult.telemetry);
-                    return nextEditResult.nextEdit.isError() ? nextEditResult.nextEdit : existingNextEditRequest2.firstEdit.p;
+                    logger.trace('reusing 2nd existing next edit request after rebase failed');
+                    const nextEditResult2 = await this._joinNextEditRequest(existingNextEditRequest2, telemetryBuilder, logContext, cancellationToken);
+                    telemetryBuilder.setStatelessNextEditTelemetry(nextEditResult2.telemetry);
+                    return nextEditResult2.nextEdit.isError() ? nextEditResult2.nextEdit : existingNextEditRequest2.firstEdit.p;
                 }
-                tracer.trace('creating new next edit request after rebase failed');
+                logger.trace('creating new next edit request after rebase failed');
             }
         }
-        const res = await this._executeNewNextEditRequest(req, doc, historyContext, nesConfigs, shouldExpandEditWindow, tracer, telemetryBuilder, cancellationToken);
+        const res = await this._executeNewNextEditRequest(req, doc, historyContext, nesConfigs, shouldExpandEditWindow, logger, telemetryBuilder, cancellationToken);
         const nextEditRequest = res.nextEditRequest;
         const nextEditResult = res.nextEditResult;
         telemetryBuilder.setStatelessNextEditTelemetry(nextEditResult.telemetry);
@@ -356,7 +411,7 @@ let NextEditProvider = class NextEditProvider extends lifecycle_1.Disposable {
     }
     async _joinNextEditRequest(nextEditRequest, telemetryBuilder, logContext, cancellationToken) {
         // TODO: Will the telemetry look alright in this case?
-        telemetryBuilder.setHeaderRequestId(nextEditRequest.id);
+        telemetryBuilder.setHeaderRequestId(nextEditRequest.headerRequestId);
         telemetryBuilder.setIsFromCache();
         telemetryBuilder.setRequest(nextEditRequest);
         logContext.setRequestInput(nextEditRequest);
@@ -369,21 +424,15 @@ let NextEditProvider = class NextEditProvider extends lifecycle_1.Disposable {
             disp.dispose();
         }
     }
-    async _executeNewNextEditRequest(req, doc, historyContext, nesConfigs, shouldExpandEditWindow, parentTracer, telemetryBuilder, cancellationToken) {
+    async _executeNewNextEditRequest(req, doc, historyContext, nesConfigs, shouldExpandEditWindow, parentLogger, telemetryBuilder, cancellationToken) {
         const curDocId = doc.id;
-        const tracer = parentTracer.sub('_executeNewNextEditRequest');
+        const logger = parentLogger.createSubLogger('_executeNewNextEditRequest');
         const recording = this._debugRecorder?.getRecentLog();
         const logContext = req.log;
         const activeDocAndIdx = assertDefined(historyContext.getDocumentAndIdx(curDocId));
         const activeDocSelection = doc.selection.get()[0];
         const projectedDocuments = historyContext.documents.map(doc => this._processDoc(doc));
         const xtabEditHistory = this._xtabHistoryTracker.getHistory();
-        function convertLineEditToEdit(nextLineEdit, docId) {
-            const doc = projectedDocuments.find(d => d.nextEditDoc.id === docId);
-            const rootedLineEdit = new rootedLineEdit_1.RootedLineEdit(doc.documentAfterEdits, nextLineEdit);
-            const suggestedEdit = rootedLineEdit.toEdit();
-            return suggestedEdit;
-        }
         const firstEdit = new async_1.DeferredPromise();
         const nLinesEditWindow = (shouldExpandEditWindow
             ? this._configService.getExperimentBasedConfig(configurationService_1.ConfigKey.TeamInternal.InlineEditsAutoExpandEditWindowLines, this._expService)
@@ -416,123 +465,138 @@ let NextEditProvider = class NextEditProvider extends lifecycle_1.Disposable {
             data.value.changes.forEach(edit => {
                 if (nextEditRequest.intermediateUserEdit && !edit.isEmpty()) {
                     nextEditRequest.intermediateUserEdit = nextEditRequest.intermediateUserEdit.compose(edit);
-                    if (!(0, editRebase_1.checkEditConsistency)(nextEditRequest.documentBeforeEdits.value, nextEditRequest.intermediateUserEdit, data.value.value.value, tracer)) {
+                    if (!(0, editRebase_1.checkEditConsistency)(nextEditRequest.documentBeforeEdits.value, nextEditRequest.intermediateUserEdit, data.value.value.value, logger)) {
                         nextEditRequest.intermediateUserEdit = undefined;
                     }
                 }
             });
         }) : undefined);
-        const createPushEdit = () => {
-            let ithEdit = -1;
-            const statePerDoc = new cache_1.CachedFunction((id) => {
-                const doc = projectedDocuments.find(d => d.nextEditDoc.id === id);
-                if (!doc) {
-                    throw new errors_1.BugIndicatingError();
-                }
-                return {
-                    docContents: doc.documentAfterEdits,
-                    editsSoFar: stringEdit_1.StringEdit.empty,
-                    nextEdits: [],
-                    docId: id,
-                };
-            });
-            const pushEdit = (result) => {
-                const myTracer = tracer.sub('pushEdit');
-                ++ithEdit;
-                myTracer.trace(`processing edit #${ithEdit} (starts at 0)`);
-                if (result.isError()) { // either error or stream of edits ended
-                    // if there was a request made, and it ended without any edits, reset shouldExpandEditWindow
-                    if (ithEdit === 0 && result.err instanceof statelessNextEditProvider_1.NoNextEditReason.NoSuggestions) {
-                        myTracer.trace('resetting shouldExpandEditWindow to false due to NoSuggestions');
-                        this._shouldExpandEditWindow = false;
-                    }
-                    if (statePerDoc.get(curDocId).nextEdits.length) {
-                        myTracer.returns(`${statePerDoc.get(curDocId).nextEdits.length} edits returned`);
-                    }
-                    else {
-                        myTracer.returns(`no edit, reason: ${result.err.kind}`);
-                        if (result.err instanceof statelessNextEditProvider_1.NoNextEditReason.NoSuggestions) {
-                            const { documentBeforeEdits, window } = result.err;
-                            let reducedWindow = window;
-                            if (activeDocSelection && window) {
-                                const cursorOffset = activeDocSelection.endExclusive;
-                                const t = documentBeforeEdits.getTransformer();
-                                const cursorPosition = t.getPosition(cursorOffset);
-                                const lineOffset = t.getOffset(cursorPosition.with(undefined, 1));
-                                const lineEndOffset = t.getOffset(cursorPosition.with(undefined, t.getLineLength(cursorPosition.lineNumber) + 1));
-                                const reducedOffset = t.getOffset(t.getPosition(window.start).delta(1));
-                                const reducedEndPosition = t.getPosition(window.endExclusive).delta(-2);
-                                const reducedEndOffset = t.getOffset(reducedEndPosition.column > 1 ? reducedEndPosition.with(undefined, t.getLineLength(reducedEndPosition.lineNumber) + 1) : reducedEndPosition);
-                                reducedWindow = new offsetRange_1.OffsetRange(Math.min(reducedOffset, lineOffset), Math.max(reducedEndOffset, lineEndOffset));
-                            }
-                            this._nextEditCache.setNoNextEdit(curDocId, documentBeforeEdits, reducedWindow, req);
-                        }
-                    }
-                    {
-                        disp.dispose();
-                        removeFromPending();
-                    }
-                    if (!firstEdit.isSettled) {
-                        firstEdit.complete(result);
-                    }
-                    return;
+        const statePerDoc = new cache_1.CachedFunction((id) => {
+            const doc = projectedDocuments.find(d => d.nextEditDoc.id === id);
+            if (!doc) {
+                throw new errors_1.BugIndicatingError();
+            }
+            return {
+                docContents: doc.documentAfterEdits,
+                editsSoFar: stringEdit_1.StringEdit.empty,
+                nextEdits: [],
+                docId: id,
+            };
+        });
+        const editStream = this._statelessNextEditProvider.provideNextEdit(nextEditRequest, logger, logContext, nextEditRequest.cancellationTokenSource.token);
+        let ithEdit = -1;
+        const processEdit = (streamedEdit, telemetry) => {
+            ++ithEdit;
+            const myLogger = logger.createSubLogger('processEdit');
+            myLogger.trace(`processing edit #${ithEdit} (starts at 0)`);
+            // reset shouldExpandEditWindow to false when we get any edit
+            myLogger.trace('resetting shouldExpandEditWindow to false due to receiving an edit');
+            this._shouldExpandEditWindow = false;
+            const targetDocState = statePerDoc.get(streamedEdit.targetDocument ?? curDocId);
+            const singleLineEdit = streamedEdit.edit;
+            const lineEdit = new lineEdit_1.LineEdit([singleLineEdit]);
+            const edit = convertLineEditToEdit(lineEdit, projectedDocuments, targetDocState.docId);
+            const rebasedEdit = edit.tryRebase(targetDocState.editsSoFar);
+            if (rebasedEdit === undefined) {
+                myLogger.trace(`edit ${ithEdit} is undefined after rebasing`);
+                if (!firstEdit.isSettled) {
+                    firstEdit.complete(result_1.Result.error(new statelessNextEditProvider_1.NoNextEditReason.Uncategorized(new Error('Rebased edit is undefined'))));
                 }
-                // reset shouldExpandEditWindow to false when we get any edit
-                myTracer.trace('resetting shouldExpandEditWindow to false due to receiving an edit');
+                return undefined;
+            }
+            targetDocState.editsSoFar = targetDocState.editsSoFar.compose(rebasedEdit);
+            let cachedEdit;
+            if (rebasedEdit.replacements.length === 0) {
+                myLogger.trace(`WARNING: ${ithEdit} has no edits`);
+            }
+            else if (rebasedEdit.replacements.length > 1) {
+                myLogger.trace(`WARNING: ${ithEdit} has ${rebasedEdit.replacements.length} edits, but expected only 1`);
+            }
+            else {
+                // populate the cache
+                const nextEditReplacement = rebasedEdit.replacements[0];
+                targetDocState.nextEdits.push(nextEditReplacement);
+                cachedEdit = this._nextEditCache.setKthNextEdit(targetDocState.docId, targetDocState.docContents, ithEdit === 0 ? streamedEdit.window : undefined, nextEditReplacement, ithEdit, ithEdit === 0 ? targetDocState.nextEdits : undefined, ithEdit === 0 ? nextEditRequest.intermediateUserEdit : undefined, req, { isFromCursorJump: streamedEdit.isFromCursorJump, originalEditWindow: streamedEdit.originalWindow });
+                myLogger.trace(`populated cache for ${ithEdit}`);
+            }
+            if (!firstEdit.isSettled) {
+                myLogger.trace('resolving firstEdit promise');
+                logContext.setResult(new rootedLineEdit_1.RootedLineEdit(targetDocState.docContents, lineEdit)); // this's correct without rebasing because this's the first edit
+                firstEdit.complete(cachedEdit ? result_1.Result.ok(cachedEdit) : result_1.Result.error(new statelessNextEditProvider_1.NoNextEditReason.Unexpected(new Error('No cached edit'))));
+            }
+            targetDocState.docContents = rebasedEdit.applyOnText(targetDocState.docContents);
+            return cachedEdit;
+        };
+        const handleStreamEnd = (completionReason, lastTelemetry) => {
+            const myLogger = logger.createSubLogger('streamEnd');
+            // if there was a request made, and it ended without any edits, reset shouldExpandEditWindow
+            const hadNoEdits = ithEdit === -1;
+            if (hadNoEdits && completionReason instanceof statelessNextEditProvider_1.NoNextEditReason.NoSuggestions) {
+                myLogger.trace('resetting shouldExpandEditWindow to false due to NoSuggestions');
                 this._shouldExpandEditWindow = false;
-                const targetDocState = statePerDoc.get(result.val.targetDocument ?? curDocId);
-                const singleLineEdit = result.val.edit;
-                const lineEdit = new lineEdit_1.LineEdit([singleLineEdit]);
-                const edit = convertLineEditToEdit(lineEdit, targetDocState.docId);
-                const rebasedEdit = edit.tryRebase(targetDocState.editsSoFar);
-                if (rebasedEdit === undefined) {
-                    myTracer.trace(`edit ${ithEdit} is undefined after rebasing`);
-                    if (!firstEdit.isSettled) {
-                        firstEdit.complete(result_1.Result.error(new statelessNextEditProvider_1.NoNextEditReason.Uncategorized(new Error('Rebased edit is undefined'))));
-                    }
-                    return;
-                }
-                targetDocState.editsSoFar = targetDocState.editsSoFar.compose(rebasedEdit);
-                let cachedEdit;
-                if (rebasedEdit.replacements.length === 0) {
-                    myTracer.trace(`WARNING: ${ithEdit} has no edits`);
-                }
-                else if (rebasedEdit.replacements.length > 1) {
-                    myTracer.trace(`WARNING: ${ithEdit} has ${rebasedEdit.replacements.length} edits, but expected only 1`);
-                }
-                else {
-                    // populate the cache
-                    const nextEdit = rebasedEdit.replacements[0];
-                    targetDocState.nextEdits.push(nextEdit);
-                    cachedEdit = this._nextEditCache.setKthNextEdit(targetDocState.docId, targetDocState.docContents, ithEdit === 0 ? result.val.window : undefined, nextEdit, ithEdit, ithEdit === 0 ? targetDocState.nextEdits : undefined, ithEdit === 0 ? nextEditRequest.intermediateUserEdit : undefined, req, { isFromCursorJump: result.val.isFromCursorJump });
-                    myTracer.trace(`populated cache for ${ithEdit}`);
-                }
-                if (!firstEdit.isSettled) {
-                    myTracer.trace('resolving firstEdit promise');
-                    logContext.setResult(new rootedLineEdit_1.RootedLineEdit(targetDocState.docContents, lineEdit)); // this's correct without rebasing because this's the first edit
-                    firstEdit.complete(cachedEdit ? result_1.Result.ok(cachedEdit) : result_1.Result.error(new statelessNextEditProvider_1.NoNextEditReason.Unexpected(new Error('No cached edit'))));
+            }
+            if (statePerDoc.get(curDocId).nextEdits.length) {
+                myLogger.trace(`${statePerDoc.get(curDocId).nextEdits.length} edits returned`);
+            }
+            else {
+                myLogger.trace(`no edit, reason: ${completionReason.kind}`);
+                if (completionReason instanceof statelessNextEditProvider_1.NoNextEditReason.NoSuggestions) {
+                    const { documentBeforeEdits, window } = completionReason;
+                    const reducedWindow = window ? computeReducedWindow(window, activeDocSelection, documentBeforeEdits) : undefined;
+                    this._nextEditCache.setNoNextEdit(curDocId, documentBeforeEdits, reducedWindow, req);
                 }
-                targetDocState.docContents = rebasedEdit.applyOnText(targetDocState.docContents);
-            };
-            return pushEdit;
+            }
+            if (!firstEdit.isSettled) {
+                firstEdit.complete(result_1.Result.error(completionReason));
+            }
+            const resultForTelemetry = statePerDoc.get(curDocId).nextEdits.length > 0
+                ? result_1.Result.ok(undefined)
+                : result_1.Result.error(completionReason);
+            const result = new statelessNextEditProvider_1.StatelessNextEditResult(resultForTelemetry, lastTelemetry);
+            nextEditRequest.setResult(result);
+            disp.dispose();
+            removeFromPending();
+            return result;
         };
-        const pushEdit = createPushEdit();
         try {
-            nextEditResult = await this._statelessNextEditProvider.provideNextEdit(nextEditRequest, pushEdit, tracer, logContext, nextEditRequest.cancellationTokenSource.token);
-            nextEditRequest.setResult(nextEditResult);
+            let res = await editStream.next();
+            if (res.done) {
+                // Stream ended immediately without any edits
+                const completionReason = res.value.v;
+                nextEditResult = handleStreamEnd(completionReason, res.value.telemetryBuilder);
+            }
+            else {
+                // Process first edit synchronously
+                const firstStreamedEdit = res.value.v;
+                const firstTelemetry = res.value.telemetryBuilder;
+                processEdit(firstStreamedEdit, firstTelemetry);
+                // Continue streaming remaining edits in the background (unawaited)
+                (async () => {
+                    try {
+                        res = await editStream.next();
+                        while (!res.done) {
+                            const streamedEdit = res.value.v;
+                            processEdit(streamedEdit, res.value.telemetryBuilder);
+                            res = await editStream.next();
+                        }
+                        // Stream completed
+                        const completionReason = res.value.v;
+                        handleStreamEnd(completionReason, res.value.telemetryBuilder);
+                    }
+                    catch (err) {
+                        logger.trace(`Error while streaming further edits: ${errors.toString(err)}`);
+                        const errorReason = new statelessNextEditProvider_1.NoNextEditReason.Unexpected(errors.fromUnknown(err));
+                        handleStreamEnd(errorReason, firstTelemetry);
+                    }
+                })();
+                // Return early with streaming result
+                nextEditResult = statelessNextEditProvider_1.StatelessNextEditResult.streaming(new statelessNextEditProvider_1.StatelessNextEditTelemetryBuilder(nextEditRequest.headerRequestId));
+            }
         }
         catch (err) {
             nextEditRequest.setResultError(err);
             throw err;
         }
-        finally {
-            if (!nextEditResult || nextEditResult.nextEdit.isError()) {
-                // when streaming, we need to keep the response going unless UI cancels it
-                // if we remove it from pending here, when UI cancels, we cannot cancel it because we think that the request has finished
-                disp.dispose();
-                removeFromPending();
-            }
-        }
         return { nextEditRequest, nextEditResult };
     }
     _hookupCancellation(nextEditRequest, cancellationToken, attachedDisposable) {
@@ -575,9 +639,9 @@ let NextEditProvider = class NextEditProvider extends lifecycle_1.Disposable {
         nextEditRequest.liveDependentants++;
         return disposables;
     }
-    computeMinimumResponseDelay({ triggerTime, isRebasedCachedEdit, isSubsequentCachedEdit, enforceCacheDelay }, tracer) {
+    computeMinimumResponseDelay({ triggerTime, isRebasedCachedEdit, isSubsequentCachedEdit, enforceCacheDelay }, logger) {
         if (!enforceCacheDelay) {
-            tracer.trace('[minimumDelay] no minimum delay enforced due to enforceCacheDelay being false');
+            logger.trace('[minimumDelay] no minimum delay enforced due to enforceCacheDelay being false');
             return 0;
         }
         const cacheDelay = this._configService.getExperimentBasedConfig(configurationService_1.ConfigKey.TeamInternal.InlineEditsCacheDelay, this._expService);
@@ -593,22 +657,251 @@ let NextEditProvider = class NextEditProvider extends lifecycle_1.Disposable {
         const nextEditProviderCallLatency = Date.now() - triggerTime;
         // if the provider call took longer than the minimum delay, we don't need to delay further
         const delay = Math.max(0, minimumResponseDelay - nextEditProviderCallLatency);
-        tracer.trace(`[minimumDelay] expected delay: ${minimumResponseDelay}ms, effective delay: ${delay}. isRebasedCachedEdit: ${isRebasedCachedEdit} (rebasedCacheDelay: ${rebasedCacheDelay}), isSubsequentCachedEdit: ${isSubsequentCachedEdit} (subsequentCacheDelay: ${subsequentCacheDelay})`);
+        logger.trace(`[minimumDelay] expected delay: ${minimumResponseDelay}ms, effective delay: ${delay}. isRebasedCachedEdit: ${isRebasedCachedEdit} (rebasedCacheDelay: ${rebasedCacheDelay}), isSubsequentCachedEdit: ${isSubsequentCachedEdit} (subsequentCacheDelay: ${subsequentCacheDelay})`);
         return delay;
     }
     handleShown(suggestion) {
         this._lastShownTime = Date.now();
+        this._lastShownSuggestionId = suggestion.requestId;
+        // Trigger speculative request for the post-edit document state
+        const speculativeRequestsEnabled = this._configService.getExperimentBasedConfig(configurationService_1.ConfigKey.TeamInternal.InlineEditsSpeculativeRequests, this._expService);
+        if (speculativeRequestsEnabled) {
+            void this._triggerSpeculativeRequest(suggestion);
+        }
+    }
+    async _triggerSpeculativeRequest(suggestion) {
+        const logger = this._logger.createSubLogger('_triggerSpeculativeRequest');
+        const result = suggestion.result;
+        if (!result?.edit) {
+            logger.trace('no edit in suggestion result');
+            return;
+        }
+        const docId = result.targetDocumentId;
+        if (!docId) {
+            logger.trace('no target document ID in suggestion result');
+            return;
+        }
+        // Compute the post-edit document content
+        const postEditContent = result.edit.replace(result.documentBeforeEdits.value);
+        const postEditCursorOffset = result.edit.replaceRange.endExclusive + result.edit.getLengthDelta();
+        const selections = [new offsetRange_1.OffsetRange(postEditCursorOffset, postEditCursorOffset)];
+        const rootedEdit = new edit_1.RootedEdit(result.documentBeforeEdits, new stringEdit_1.StringEdit([result.edit]));
+        const postEditContentST = new abstractText_1.StringText(postEditContent);
+        let cachedEdit = this._nextEditCache.lookupNextEdit(docId, postEditContentST, selections);
+        let shiftedSelection;
+        if (cachedEdit) {
+            // first cachedEdit should be without edits because of noSuggestions caching
+            if (cachedEdit.edit) {
+                logger.trace('already have cached edit for post-edit state');
+                return;
+            }
+            else if (cachedEdit.editWindow) {
+                const trans = postEditContentST.getTransformer();
+                const endOfEditWindow = trans.getPosition(cachedEdit.editWindow.endExclusive - 1);
+                const shiftedCursorLineNumber = (endOfEditWindow.lineNumber + 1 < postEditContentST.lineRange.endLineNumberExclusive
+                    ? endOfEditWindow.lineNumber + 1
+                    : endOfEditWindow.lineNumber);
+                const shiftedSelectionCursorOffset = trans.getOffset(new position_1.Position(shiftedCursorLineNumber, 1));
+                shiftedSelection = new offsetRange_1.OffsetRange(shiftedSelectionCursorOffset, shiftedSelectionCursorOffset);
+                cachedEdit = this._nextEditCache.lookupNextEdit(docId, postEditContentST, [shiftedSelection]);
+                if (cachedEdit?.edit) {
+                    logger.trace('already have cached edit for post-edit state (after shifting selection)');
+                    return;
+                }
+            }
+            else {
+                logger.trace('already have cached no-suggestions entry for post-edit state');
+                return;
+            }
+        }
+        // Check if we already have a pending request for the post-edit state
+        if (this._pendingStatelessNextEditRequest?.documentBeforeEdits.value === postEditContent) {
+            logger.trace('already have pending request for post-edit state');
+            return;
+        }
+        // Check if we already have a speculative request for this post-edit state
+        if (this._speculativePendingRequest?.postEditContent === postEditContent) {
+            logger.trace('already have speculative request for post-edit state');
+            return;
+        }
+        // Get the document to trigger speculative fetch
+        // Note: targetDocumentId is defined when the suggestion targets a different document
+        // Otherwise, use the file path from the log context
+        const doc = this._workspace.getDocument(docId);
+        if (!doc) {
+            logger.trace('document not found for speculative request');
+            return;
+        }
+        // Cancel any previous speculative request
+        this._speculativePendingRequest?.request.cancellationTokenSource.cancel();
+        this._speculativePendingRequest = null;
+        const historyContext = this._historyContextProvider.getHistoryContext(docId);
+        if (!historyContext) {
+            logger.trace('no history context for speculative request');
+            return;
+        }
+        // Create a speculative request
+        // Use a dummy version since this is speculative and we don't have the actual post-edit version
+        const logContext = new inlineEditLogContext_1.InlineEditRequestLogContext(docId.uri, 0, undefined);
+        const req = new NextEditFetchRequest(`sp-${suggestion.source.opportunityId}`, logContext, undefined, `sp-${(0, uuid_1.generateUuid)()}`);
+        logger.trace(`triggering speculative request for post-edit state (opportunityId=${req.opportunityId}, headerRequestId=${req.headerRequestId})`);
+        logger.trace(`triggering speculative request for post-edit state (opportunityId=${req.opportunityId}, headerRequestId=${req.headerRequestId})`);
+        try {
+            const speculativeRequest = await this._createSpeculativeRequest(req, doc, shiftedSelection, historyContext, postEditContent, rootedEdit, result.edit, logger);
+            if (speculativeRequest) {
+                this._speculativePendingRequest = {
+                    request: speculativeRequest,
+                    postEditContent,
+                };
+            }
+        }
+        catch (e) {
+            logger.trace(`speculative request failed: ${errors.toString(e)}`);
+        }
+    }
+    /**
+     * Creates and starts a speculative request for the post-edit document state.
+     * The request will populate the cache so that when the user accepts the suggestion,
+     * the next NES request can reuse or find the result in cache.
+     */
+    async _createSpeculativeRequest(req, doc, shiftedSelection, historyContext, postEditContent, rootedEdit, appliedEdit, parentLogger) {
+        const logger = parentLogger.createSubLogger('_createSpeculativeRequest');
+        const curDocId = doc.id;
+        const recording = this._debugRecorder?.getRecentLog();
+        const logContext = req.log;
+        const activeDocAndIdx = historyContext.getDocumentAndIdx(curDocId);
+        if (!activeDocAndIdx) {
+            logger.trace('active doc not found in history context');
+            return undefined;
+        }
+        // Create the post-edit document content
+        const postEditText = new abstractText_1.StringText(postEditContent);
+        // Process documents, but for the active document, use the post-edit state
+        const projectedDocuments = historyContext.documents.map(docHist => {
+            if (docHist.docId !== curDocId) {
+                return this._processDoc(docHist);
+            }
+            else {
+                // For the active document, create a version representing post-edit state
+                // The "recent edit" from the model's perspective is the NES edit we just applied
+                const workspaceRoot = this._workspace.getWorkspaceRoot(curDocId);
+                const postEditEdit = new stringEdit_1.StringEdit([appliedEdit]);
+                const postEditLineEdit = rootedLineEdit_1.RootedLineEdit.fromEdit(new edit_1.RootedEdit(doc.value.get(), postEditEdit)).removeCommonSuffixPrefixLines().edit;
+                let selection = shiftedSelection;
+                if (selection === undefined) {
+                    const appliedEditEndPos = postEditText.getTransformer().getPosition(appliedEdit.replaceRange.endExclusive + appliedEdit.getLengthDelta());
+                    const pos = new position_1.Position(appliedEditEndPos.lineNumber, 1);
+                    const offset = postEditText.getTransformer().getOffset(pos);
+                    selection = new offsetRange_1.OffsetRange(offset, offset);
+                }
+                const nextEditDoc = new statelessNextEditProvider_1.StatelessNextEditDocument(curDocId, workspaceRoot, docHist.languageId, doc.value.get().getLines(), // lines before the NES edit
+                postEditLineEdit, // the NES edit as LineEdit
+                doc.value.get(), // document before NES edit
+                edit_1.Edits.single(postEditEdit), // the NES edit as Edits
+                selection);
+                return {
+                    recentEdit: new edit_1.RootedEdit(doc.value.get(), postEditEdit),
+                    nextEditDoc,
+                    documentAfterEdits: postEditText,
+                };
+            }
+        });
+        const xtabEditHistory = this._xtabHistoryTracker.getHistory();
+        const suggestedEdit = { kind: 'edit', docId: curDocId, edit: rootedEdit };
+        xtabEditHistory.push(suggestedEdit);
+        const firstEdit = new async_1.DeferredPromise();
+        const nLinesEditWindow = this._configService.getExperimentBasedConfig(configurationService_1.ConfigKey.TeamInternal.InlineEditsAutoExpandEditWindowLines, this._expService);
+        const nextEditRequest = new statelessNextEditProvider_1.StatelessNextEditRequest(req.headerRequestId, req.opportunityId, postEditText, // documentBeforeEdits is the post-edit state
+        projectedDocuments.map(d => d.nextEditDoc), activeDocAndIdx.idx, xtabEditHistory, firstEdit, nLinesEditWindow, logContext, undefined, // recordingBookmark
+        recording, undefined);
+        logger.trace('starting speculative provider call');
+        // Start the provider call - this runs in the background and populates the cache
+        const label = `NES | spec | ${(0, path_1.basename)(doc.id.toUri().fsPath)} (v${doc.version})`;
+        const capturingToken = new capturingToken_1.CapturingToken(label, undefined, true, true);
+        void this._requestLogger.captureInvocation(capturingToken, () => this._runSpeculativeProviderCall(nextEditRequest, projectedDocuments, curDocId, req, logger));
+        return nextEditRequest;
+    }
+    /**
+     * Runs the provider call for a speculative request and caches results.
+     */
+    async _runSpeculativeProviderCall(nextEditRequest, projectedDocuments, curDocId, req, parentLogger) {
+        const logger = parentLogger.createSubLogger('_runSpeculativeProviderCall');
+        const statePerDoc = new cache_1.CachedFunction((id) => {
+            const doc = projectedDocuments.find(d => d.nextEditDoc.id === id);
+            if (!doc) {
+                throw new errors_1.BugIndicatingError();
+            }
+            return {
+                docContents: doc.documentAfterEdits,
+                editsSoFar: stringEdit_1.StringEdit.empty,
+                nextEdits: [],
+                docId: id,
+            };
+        });
+        const logContext = req.log;
+        const editStream = this._statelessNextEditProvider.provideNextEdit(nextEditRequest, logger, logContext, nextEditRequest.cancellationTokenSource.token);
+        let ithEdit = -1;
+        try {
+            let res = await editStream.next();
+            if (res.done) {
+                nextEditRequest.firstEdit.complete(result_1.Result.error(res.value.v));
+                nextEditRequest.setResult(new statelessNextEditProvider_1.StatelessNextEditResult(result_1.Result.error(res.value.v), res.value.telemetryBuilder));
+                logger.trace('speculative request completed with no edits');
+            }
+            else {
+                (async () => {
+                    while (!res.done) {
+                        ++ithEdit;
+                        const streamedEdit = res.value.v;
+                        const targetDocState = statePerDoc.get(streamedEdit.targetDocument ?? curDocId);
+                        const singleLineEdit = streamedEdit.edit;
+                        const lineEdit = new lineEdit_1.LineEdit([singleLineEdit]);
+                        const edit = convertLineEditToEdit(lineEdit, projectedDocuments, targetDocState.docId);
+                        const rebasedEdit = edit.tryRebase(targetDocState.editsSoFar);
+                        if (rebasedEdit === undefined) {
+                            logger.trace(`speculative edit ${ithEdit} rebasing failed`);
+                            res = await editStream.next();
+                            continue;
+                        }
+                        targetDocState.editsSoFar = targetDocState.editsSoFar.compose(rebasedEdit);
+                        if (rebasedEdit.replacements.length === 1) {
+                            const nextEditReplacement = rebasedEdit.replacements[0];
+                            targetDocState.nextEdits.push(nextEditReplacement);
+                            // Populate the cache with the speculative result
+                            const cachedEdit = this._nextEditCache.setKthNextEdit(targetDocState.docId, targetDocState.docContents, ithEdit === 0 ? streamedEdit.window : undefined, nextEditReplacement, ithEdit, ithEdit === 0 ? targetDocState.nextEdits : undefined, undefined, // no userEditSince for speculative
+                            req, { isFromCursorJump: streamedEdit.isFromCursorJump, originalEditWindow: streamedEdit.originalWindow });
+                            if (!nextEditRequest.firstEdit.isSettled && cachedEdit) {
+                                nextEditRequest.firstEdit.complete(result_1.Result.ok(cachedEdit));
+                                nextEditRequest.setResult(new statelessNextEditProvider_1.StatelessNextEditResult(result_1.Result.ok(undefined), res.value.telemetryBuilder));
+                            }
+                            logger.trace(`cached speculative edit ${ithEdit}`);
+                        }
+                        targetDocState.docContents = rebasedEdit.applyOnText(targetDocState.docContents);
+                        res = await editStream.next();
+                    }
+                })().finally(() => {
+                    if (!nextEditRequest.firstEdit.isSettled) {
+                        nextEditRequest.firstEdit.complete(result_1.Result.error(new statelessNextEditProvider_1.NoNextEditReason.Uncategorized(new Error('Speculative request ended without edits'))));
+                        nextEditRequest.setResult(new statelessNextEditProvider_1.StatelessNextEditResult(result_1.Result.error(new statelessNextEditProvider_1.NoNextEditReason.Uncategorized(new Error('Speculative request ended without edits'))), res.value.telemetryBuilder));
+                    }
+                });
+            }
+            logger.trace(`speculative request completed with ${ithEdit + 1} edits`);
+        }
+        catch (e) {
+            logger.trace(`speculative provider call error: ${errors.toString(e)}`);
+        }
     }
     handleAcceptance(docId, suggestion) {
         this.runSnippy(docId, suggestion);
         this._statelessNextEditProvider.handleAcceptance?.();
-        const tracer = this._tracer.subNoEntry(suggestion.source.opportunityId.substring(4, 8)).subNoEntry('handleAcceptance');
+        const logger = this._logger.createSubLogger(suggestion.source.opportunityId.substring(4, 8)).createSubLogger('handleAcceptance');
         if (suggestion === this._lastNextEditResult) {
-            tracer.trace('setting shouldExpandEditWindow to true due to acceptance of last suggestion');
+            logger.trace('setting shouldExpandEditWindow to true due to acceptance of last suggestion');
             this._shouldExpandEditWindow = true;
         }
         else {
-            tracer.trace('NOT setting shouldExpandEditWindow to true because suggestion is not the last suggestion');
+            logger.trace('NOT setting shouldExpandEditWindow to true because suggestion is not the last suggestion');
         }
     }
     handleRejection(docId, suggestion) {
@@ -623,7 +916,15 @@ let NextEditProvider = class NextEditProvider extends lifecycle_1.Disposable {
         this._lastRejectionTime = Date.now();
         this._statelessNextEditProvider.handleRejection?.();
     }
-    handleIgnored(docId, suggestion, supersededBy) { }
+    handleIgnored(docId, suggestion, supersededBy) {
+        // Check if this was the last shown suggestion
+        const wasShown = this._lastShownSuggestionId === suggestion.requestId;
+        const wasSuperseded = supersededBy !== undefined;
+        if (wasShown && !wasSuperseded) {
+            // Was shown to the user
+            this._statelessNextEditProvider.handleIgnored?.();
+        }
+    }
     async runSnippy(docId, suggestion) {
         if (suggestion.result === undefined || suggestion.result.edit === undefined) {
             return;
@@ -640,7 +941,8 @@ exports.NextEditProvider = NextEditProvider = __decorate([
     __param(5, configurationService_1.IConfigurationService),
     __param(6, snippyService_1.ISnippyService),
     __param(7, logService_1.ILogService),
-    __param(8, nullExperimentationService_1.IExperimentationService)
+    __param(8, nullExperimentationService_1.IExperimentationService),
+    __param(9, requestLogger_1.IRequestLogger)
 ], NextEditProvider);
 function assertDefined(value) {
     if (!value) {
@@ -649,11 +951,11 @@ function assertDefined(value) {
     return value;
 }
 class NextEditFetchRequest {
-    constructor(opportunityId, log, providerRequestStartDateTime) {
+    constructor(opportunityId, log, providerRequestStartDateTime, headerRequestId = (0, uuid_1.generateUuid)()) {
         this.opportunityId = opportunityId;
         this.log = log;
         this.providerRequestStartDateTime = providerRequestStartDateTime;
-        this.headerRequestId = (0, uuid_1.generateUuid)();
+        this.headerRequestId = headerRequestId;
     }
 }
 exports.NextEditFetchRequest = NextEditFetchRequest;