@vscode/chat-lib 0.43.2026040702 → 0.43.2026040706-0

package/dist/src/_internal/extension/xtab/node/xtabProvider.js

@@ -47,7 +47,7 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
 };
 var XtabProvider_1;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.EditIntentParseMode = exports.XtabProvider = void 0;
+exports.XtabProvider = void 0;
 exports.filterOutEditsWithSubstrings = filterOutEditsWithSubstrings;
 exports.computeAreaAroundEditWindowLinesRange = computeAreaAroundEditWindowLinesRange;
 exports.mapChatFetcherErrorToNoNextEditReason = mapChatFetcherErrorToNoNextEditReason;
@@ -55,8 +55,6 @@ exports.overrideModelConfig = overrideModelConfig;
 exports.pickSystemPrompt = pickSystemPrompt;
 exports.determineLanguageContextOptions = determineLanguageContextOptions;
 exports.getPredictionContents = getPredictionContents;
-exports.parseEditIntentFromStream = parseEditIntentFromStream;
-exports.findMergeConflictMarkersRange = findMergeConflictMarkersRange;
 const chatMLFetcher_1 = require("../../../platform/chat/common/chatMLFetcher");
 const commonTypes_1 = require("../../../platform/chat/common/commonTypes");
 const configurationService_1 = require("../../../platform/configuration/common/configurationService");
@@ -81,10 +79,12 @@ const nullExperimentationService_1 = require("../../../platform/telemetry/common
 const workspaceService_1 = require("../../../platform/workspace/common/workspaceService");
 const async_1 = require("../../../util/common/async");
 const asyncIterableUtils_1 = require("../../../util/common/asyncIterableUtils");
+const backwardCompatSetting_1 = require("../../../util/common/backwardCompatSetting");
 const errors_1 = require("../../../util/common/errors");
 const result_1 = require("../../../util/common/result");
 const assert_1 = require("../../../util/vs/base/common/assert");
 const async_2 = require("../../../util/vs/base/common/async");
+const cancellation_1 = require("../../../util/vs/base/common/cancellation");
 const path_1 = require("../../../util/vs/base/common/path");
 const stopwatch_1 = require("../../../util/vs/base/common/stopwatch");
 const uri_1 = require("../../../util/vs/base/common/uri");
@@ -95,11 +95,13 @@ const range_1 = require("../../../util/vs/editor/common/core/range");
 const lineRange_1 = require("../../../util/vs/editor/common/core/ranges/lineRange");
 const offsetRange_1 = require("../../../util/vs/editor/common/core/ranges/offsetRange");
 const abstractText_1 = require("../../../util/vs/editor/common/core/text/abstractText");
+const positionToOffset_1 = require("../../../util/vs/editor/common/core/text/positionToOffset");
 const instantiation_1 = require("../../../util/vs/platform/instantiation/common/instantiation");
 const vscodeTypesShim_1 = require("../../../util/common/test/shims/vscodeTypesShim");
 const nearbyCursorInlineEditProvider_1 = require("../../inlineEdits/common/nearbyCursorInlineEditProvider");
 const userInteractionMonitor_1 = require("../../inlineEdits/common/userInteractionMonitor");
 const importFiltering_1 = require("../../inlineEdits/node/importFiltering");
+const fetchStreamError_1 = require("../common/fetchStreamError");
 const inlineSuggestion_1 = require("../common/inlineSuggestion");
 const lintErrors_1 = require("../common/lintErrors");
 const promptCrafting_1 = require("../common/promptCrafting");
@@ -109,6 +111,9 @@ const systemMessages_1 = require("../common/systemMessages");
 const tags_1 = require("../common/tags");
 const terminalOutput_1 = require("../common/terminalOutput");
 const xtabCurrentDocument_1 = require("../common/xtabCurrentDocument");
+const cursorLineDivergence_1 = require("./cursorLineDivergence");
+const editIntent_1 = require("./editIntent");
+const responseFormatHandlers_1 = require("./responseFormatHandlers");
 const xtabCustomDiffPatchResponseHandler_1 = require("./xtabCustomDiffPatchResponseHandler");
 const xtabEndpoint_1 = require("./xtabEndpoint");
 const xtabNextCursorPredictor_1 = require("./xtabNextCursorPredictor");
@@ -134,6 +139,27 @@ var RetryState;
     }
     RetryState.Retrying = Retrying;
 })(RetryState || (RetryState = {}));
+var FetchResult;
+(function (FetchResult) {
+    class Lines {
+        constructor(linesStream, getResponseSoFar, fetchRequestStopWatch) {
+            this.linesStream = linesStream;
+            this.getResponseSoFar = getResponseSoFar;
+            this.fetchRequestStopWatch = fetchRequestStopWatch;
+        }
+    }
+    FetchResult.Lines = Lines;
+    class ModelNotFound {
+        static { this.INSTANCE = new ModelNotFound(); }
+    }
+    FetchResult.ModelNotFound = ModelNotFound;
+    class FetchFailure {
+        constructor(reason) {
+            this.reason = reason;
+        }
+    }
+    FetchResult.FetchFailure = FetchFailure;
+})(FetchResult || (FetchResult = {}));
 let XtabProvider = class XtabProvider {
     static { XtabProvider_1 = this; }
     static { this.ID = configurationService_1.XTabProviderId; }
@@ -174,7 +200,8 @@ let XtabProvider = class XtabProvider {
                 return new statelessNextEditProvider_1.WithStatelessProviderTelemetry(noSuggestionReason, telemetry.build(result_1.Result.error(noSuggestionReason)));
             }
             const delaySession = this.userInteractionMonitor.createDelaySession(request.providerRequestStartDateTime);
-            const iterator = this.doGetNextEdit(request, delaySession, logger, logContext, cancellationToken, telemetry, RetryState.NotRetrying.INSTANCE);
+            const tracing = { tracer: logger, logContext, telemetry };
+            const iterator = this.doGetNextEdit(request, delaySession, tracing, cancellationToken, RetryState.NotRetrying.INSTANCE);
             let res = await iterator.next(); // for-async-await loop doesn't work because we need to access the final return value
             while (!res.done) {
                 yield new statelessNextEditProvider_1.WithStatelessProviderTelemetry(res.value, telemetry.build(result_1.Result.ok(undefined)));
@@ -195,29 +222,30 @@ let XtabProvider = class XtabProvider {
             logContext.setProviderEndTime();
         }
     }
-    doGetNextEdit(request, delaySession, logger, logContext, cancellationToken, telemetryBuilder, retryState) {
-        return this.doGetNextEditWithSelection(request, (0, nearbyCursorInlineEditProvider_1.getOrDeduceSelectionFromLastEdit)(request.getActiveDocument()), delaySession, logger, logContext, cancellationToken, telemetryBuilder, retryState);
+    doGetNextEdit(request, delaySession, tracing, cancellationToken, retryState) {
+        return this.doGetNextEditWithSelection(request, (0, nearbyCursorInlineEditProvider_1.getOrDeduceSelectionFromLastEdit)(request.getActiveDocument()), delaySession, tracing, cancellationToken, retryState);
     }
-    async *doGetNextEditWithSelection(request, selection, delaySession, parentTracer, logContext, cancellationToken, telemetryBuilder, retryState, 
+    async *doGetNextEditWithSelection(request, selection, delaySession, tracing, cancellationToken, retryState, 
     /**
      * For cursor jump scenarios, this is the edit window around the original cursor position
      * (before the jump). When provided, yielded edits will include this as `originalWindow`
      * so the cache can serve the edit when the cursor is in either location.
      */
     originalEditWindow) {
-        const tracer = parentTracer.createSubLogger(['XtabProvider', 'doGetNextEditWithSelection']);
+        const tracer = tracing.tracer.createSubLogger(['XtabProvider', 'doGetNextEditWithSelection']);
+        const { logContext, telemetry } = tracing;
         const activeDocument = request.getActiveDocument();
         if (selection === null) {
             return new statelessNextEditProvider_1.NoNextEditReason.Uncategorized(new Error('NoSelection'));
         }
         const { promptOptions, modelServiceConfig } = this.determineModelConfiguration(activeDocument);
-        telemetryBuilder.setModelConfig(JSON.stringify(modelServiceConfig));
-        const endpoint = this.getEndpointWithLogging(promptOptions.modelName, logContext, telemetryBuilder);
+        telemetry.setModelConfig(JSON.stringify(modelServiceConfig));
+        const endpoint = this.getEndpointWithLogging(promptOptions.modelName, logContext, telemetry);
         const cursorPosition = new position_1.Position(selection.endLineNumber, selection.endColumn);
         const currentDocument = new xtabCurrentDocument_1.CurrentDocument(activeDocument.documentAfterEdits, cursorPosition);
-        this._configureDebounceTimings(request, currentDocument, promptOptions, telemetryBuilder, delaySession, tracer);
+        this._configureDebounceTimings(request, currentDocument, promptOptions, telemetry, delaySession, tracer);
         const areaAroundEditWindowLinesRange = computeAreaAroundEditWindowLinesRange(currentDocument);
-        const editWindowLinesRange = this.computeEditWindowLinesRange(currentDocument, request, tracer, telemetryBuilder);
+        const editWindowLinesRange = this.computeEditWindowLinesRange(currentDocument, request, tracer, telemetry);
         const cursorOriginalLinesOffset = Math.max(0, currentDocument.cursorLineOffset - editWindowLinesRange.start);
         const editWindowLastLineLength = currentDocument.transformer.getLineLength(editWindowLinesRange.endExclusive);
         const editWindow = currentDocument.transformer.getOffsetRange(new range_1.Range(editWindowLinesRange.start + 1, 1, editWindowLinesRange.endExclusive, editWindowLastLineLength + 1));
@@ -242,25 +270,25 @@ let XtabProvider = class XtabProvider {
             return new statelessNextEditProvider_1.NoNextEditReason.PromptTooLarge('currentFile');
         }
         const { clippedTaggedCurrentDoc, areaAroundCodeToEdit } = taggedCurrentFileContentResult.val;
-        telemetryBuilder.setNLinesOfCurrentFileInPrompt(clippedTaggedCurrentDoc.lines.length);
+        telemetry.setNLinesOfCurrentFileInPrompt(clippedTaggedCurrentDoc.lines.length);
         const { aggressivenessLevel, userHappinessScore } = this.userInteractionMonitor.getAggressivenessLevel();
         // Log user's raw aggressiveness setting when explicitly changed from default
         const userAggressivenessSetting = this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.Advanced.InlineEditsAggressiveness, this.expService);
-        telemetryBuilder.setUserAggressivenessSetting(userAggressivenessSetting);
+        telemetry.setUserAggressivenessSetting(userAggressivenessSetting);
         // Log aggressiveness level and user happiness score
-        telemetryBuilder.setXtabAggressivenessLevel(aggressivenessLevel);
+        telemetry.setXtabAggressivenessLevel(aggressivenessLevel);
         if (userHappinessScore !== undefined) {
-            telemetryBuilder.setXtabUserHappinessScore(userHappinessScore);
+            telemetry.setXtabUserHappinessScore(userHappinessScore);
         }
-        const langCtx = await this.getAndProcessLanguageContext(request, delaySession, activeDocument, cursorPosition, promptOptions, tracer, logContext, cancellationToken);
+        const langCtx = await this.getAndProcessLanguageContext(request, delaySession, activeDocument, cursorPosition, promptOptions, { tracer, logContext, telemetry }, cancellationToken);
         if (cancellationToken.isCancellationRequested) {
             return new statelessNextEditProvider_1.NoNextEditReason.GotCancelled('afterLanguageContextAwait');
         }
         const lintErrors = new lintErrors_1.LintErrors(activeDocument.id, currentDocument, this.langDiagService, request.xtabEditHistory);
         const promptPieces = new promptCrafting_1.PromptPieces(currentDocument, editWindowLinesRange, areaAroundEditWindowLinesRange, activeDocument, request.xtabEditHistory, clippedTaggedCurrentDoc.lines, areaAroundCodeToEdit, langCtx, aggressivenessLevel, lintErrors, XtabProvider_1.computeTokens, promptOptions);
         const { prompt: userPrompt, nDiffsInPrompt, diffTokensInPrompt } = (0, promptCrafting_1.getUserPrompt)(promptPieces);
-        telemetryBuilder.setNDiffsInPrompt(nDiffsInPrompt);
-        telemetryBuilder.setDiffTokensInPrompt(diffTokensInPrompt);
+        telemetry.setNDiffsInPrompt(nDiffsInPrompt);
+        telemetry.setDiffTokensInPrompt(diffTokensInPrompt);
         const responseFormat = xtabPromptOptions.ResponseFormat.fromPromptingStrategy(promptOptions.promptingStrategy);
         const prediction = this.getPredictedOutput(activeDocument, editWindowLines, responseFormat);
         const messages = (0, xtabUtils_1.constructMessages)({
@@ -268,35 +296,47 @@ let XtabProvider = class XtabProvider {
             userMsg: userPrompt,
         });
         logContext.setPrompt(messages);
-        telemetryBuilder.setPrompt(messages);
+        telemetry.setPrompt(messages);
         const HARD_CHAR_LIMIT = 30000 * 4; // 30K tokens, assuming 4 chars per token -- we use approximation here because counting tokens exactly is time-consuming
         const promptCharCount = (0, xtabUtils_1.charCount)(messages);
         if (promptCharCount > HARD_CHAR_LIMIT) {
             return new statelessNextEditProvider_1.NoNextEditReason.PromptTooLarge('final');
         }
-        await this.debounce(delaySession, retryState, tracer, telemetryBuilder, cancellationToken);
+        await this.debounce(delaySession, retryState, tracer, telemetry, cancellationToken);
         if (cancellationToken.isCancellationRequested) {
             return new statelessNextEditProvider_1.NoNextEditReason.GotCancelled('afterDebounce');
         }
         // Fire-and-forget: collect lint errors and terminal output for telemetry in background to avoid blocking the main path
         Promise.resolve().then(() => {
             const lintErrorsData = lintErrors.getData();
-            telemetryBuilder.setLintErrors(lintErrorsData);
+            telemetry.setLintErrors(lintErrorsData);
             logContext.setDiagnosticsData(lintErrorsData);
             const terminalOutputData = this.terminalMonitor.getData();
-            telemetryBuilder.setTerminalOutput(terminalOutputData);
+            telemetry.setTerminalOutput(terminalOutputData);
             logContext.setTerminalData(terminalOutputData);
         });
         // Fire-and-forget: compute GhostText-style similar files context for telemetry
-        telemetryBuilder.setSimilarFilesContext(this.similarFilesContextService.compute(activeDocument.id.uri, activeDocument.languageId, activeDocument.documentAfterEdits.value, currentDocument.cursorOffset));
+        telemetry.setSimilarFilesContext(this.similarFilesContextService.compute(activeDocument.id.uri, activeDocument.languageId, activeDocument.documentAfterEdits.value, currentDocument.cursorOffset));
         request.fetchIssued = true;
-        return yield* this.streamEditsWithFiltering(request, endpoint, modelServiceConfig, messages, clippedTaggedCurrentDoc, editWindow, editWindowLines, cursorOriginalLinesOffset, editWindowLinesRange, promptPieces, prediction, {
+        const editStreamCtx = {
+            endpoint,
+            modelServiceConfig,
+            messages,
+            clippedTaggedCurrentDoc,
+            editWindowInfo: {
+                editWindow,
+                editWindowLines,
+                cursorOriginalLinesOffset,
+                editWindowLineRange: editWindowLinesRange,
+            },
+            promptPieces,
+            prediction,
+            originalEditWindow,
+        };
+        return yield* this.streamEditsWithFiltering(request, editStreamCtx, {
             shouldRemoveCursorTagFromResponse,
             responseFormat,
-            retryState,
-            aggressivenessLevel,
-            userHappinessScore,
-        }, delaySession, tracer, telemetryBuilder, logContext, cancellationToken, originalEditWindow);
+        }, { aggressivenessLevel, userHappinessScore }, retryState, delaySession, { tracer, logContext, telemetry }, cancellationToken);
     }
     _configureDebounceTimings(request, currentDocument, promptOptions, telemetry, delaySession, tracer) {
         const isCursorAtEndOfLine = currentDocument.isCursorAtEndOfLine();
@@ -356,17 +396,17 @@ let XtabProvider = class XtabProvider {
             tracer.trace(`Aggressiveness ${userAggressiveness}: min response time set to ${minResponseTimeMs}ms`);
         }
     }
-    getAndProcessLanguageContext(request, delaySession, activeDocument, cursorPosition, promptOptions, tracer, logContext, cancellationToken) {
+    getAndProcessLanguageContext(request, delaySession, activeDocument, cursorPosition, promptOptions, tracing, cancellationToken) {
         const recordingEnabled = this.configService.getConfig(configurationService_1.ConfigKey.TeamInternal.InlineEditsLogContextRecorderEnabled);
         if (!promptOptions.languageContext.enabled && !recordingEnabled) {
             return Promise.resolve(undefined);
         }
-        const langCtxPromise = this.getLanguageContext(request, delaySession, activeDocument, cursorPosition, tracer, logContext, cancellationToken);
+        const langCtxPromise = this.getLanguageContext(request, delaySession, activeDocument, cursorPosition, tracing, cancellationToken);
         // if recording, add diagnostics for the file to the recording and hook up the language context promise to write to the recording
         if (recordingEnabled) {
             langCtxPromise.then(langCtxs => {
                 if (langCtxs) {
-                    logContext.setLanguageContext(langCtxs);
+                    tracing.logContext.setLanguageContext(langCtxs);
                 }
             });
         }
@@ -374,7 +414,7 @@ let XtabProvider = class XtabProvider {
             ? langCtxPromise
             : Promise.resolve(undefined);
     }
-    async getLanguageContext(request, delaySession, activeDocument, cursorPosition, tracer, logContext, cancellationToken) {
+    async getLanguageContext(request, delaySession, activeDocument, cursorPosition, tracing, cancellationToken) {
         try {
             const textDoc = this.workspaceService.textDocuments.find(doc => doc.uri.toString() === activeDocument.id.uri);
             if (textDoc === undefined) {
@@ -434,14 +474,15 @@ let XtabProvider = class XtabProvider {
             return { start, end, items: langCtxItems };
         }
         catch (error) {
-            logContext.setError(errors_1.ErrorUtils.fromUnknown(error));
-            tracer.trace(`Failed to fetch language context: ${error}`);
+            tracing.logContext.setError(errors_1.ErrorUtils.fromUnknown(error));
+            tracing.tracer.trace(`Failed to fetch language context: ${error}`);
             return undefined;
         }
     }
-    async *streamEditsWithFiltering(request, endpoint, modelServiceConfig, messages, clippedTaggedCurrentDoc, editWindow, editWindowLines, cursorOriginalLinesOffset, editWindowLineRange, promptPieces, prediction, opts, delaySession, parentTracer, telemetryBuilder, logContext, cancellationToken, originalEditWindow) {
-        const tracer = parentTracer.createSubLogger('streamEditsWithFiltering');
-        const iterator = this.streamEdits(request, endpoint, modelServiceConfig, messages, clippedTaggedCurrentDoc, editWindow, editWindowLines, cursorOriginalLinesOffset, editWindowLineRange, promptPieces, prediction, opts, delaySession, tracer, telemetryBuilder, logContext, cancellationToken, originalEditWindow);
+    async *streamEditsWithFiltering(request, editStreamCtx, responseOpts, fetchMetadata, retryState, delaySession, tracing, cancellationToken) {
+        const tracer = tracing.tracer.createSubLogger('streamEditsWithFiltering');
+        const subTracing = { ...tracing, tracer };
+        const iterator = this.streamEdits(request, editStreamCtx, responseOpts, fetchMetadata, retryState, delaySession, subTracing, cancellationToken);
         let nEdits = 0;
         let r = await iterator.next();
         while (!r.done) {
@@ -461,22 +502,43 @@ let XtabProvider = class XtabProvider {
         if (nEdits === 0 &&
             r.value instanceof statelessNextEditProvider_1.NoNextEditReason.NoSuggestions // only retry if there was no error, cancellation, etc.
         ) {
-            return yield* this.doGetNextEditsWithCursorJump(request, modelServiceConfig, editWindow, promptPieces, delaySession, parentTracer, logContext, cancellationToken, telemetryBuilder, opts.retryState);
+            return yield* this.doGetNextEditsWithCursorJump(request, editStreamCtx, delaySession, tracing, cancellationToken, retryState);
         }
         return r.value;
     }
-    async *streamEdits(request, endpoint, modelServiceConfig, messages, clippedTaggedCurrentDoc, editWindow, editWindowLines, cursorOriginalLinesOffset, editWindowLineRange, promptPieces, prediction, opts, delaySession, parentTracer, telemetryBuilder, logContext, cancellationToken, originalEditWindow) {
-        const tracer = parentTracer.createSubLogger('streamEdits');
-        const targetDocument = request.getActiveDocument().id;
+    async *streamEdits(request, editStreamCtx, responseOpts, fetchMetadata, retryState, delaySession, tracing, cancellationToken) {
+        const tracer = tracing.tracer.createSubLogger('streamEdits');
+        // Create a local cancellation source linked to the caller's token.
+        // This lets us cancel the fetch immediately on cursor-line divergence
+        // without reaching into the request's CancellationTokenSource (which
+        // is owned by nextEditProvider.ts).
+        const fetchCts = new cancellation_1.CancellationTokenSource(cancellationToken);
+        const fetchCancellationToken = fetchCts.token;
+        try {
+            return yield* this._streamEditsImpl(request, editStreamCtx, responseOpts, fetchMetadata, retryState, delaySession, { ...tracing, tracer }, cancellationToken, fetchCts, fetchCancellationToken);
+        }
+        finally {
+            fetchCts.dispose();
+        }
+    }
+    /**
+     * Initiates the HTTP fetch, sets up the streaming pipeline, and returns either
+     * a clean line stream (with cursor-tag removal and latency logging applied)
+     * or an error / retry signal.
+     *
+     * This method encapsulates all fetch infrastructure so that downstream response
+     * format handlers only need an `AsyncIterable<string>` line stream.
+     */
+    async _performFetch(endpoint, messages, prediction, requestId, fetchMetadata, shouldRemoveCursorTagFromResponse, editWindow, documentBeforeEdits, fetchCancellationToken, tracing) {
+        const { tracer, logContext, telemetry } = tracing;
         const useFetcher = this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.NextEditSuggestionsFetcher, this.expService) || undefined;
         const fetchStreamSource = new chatMLFetcher_1.FetchStreamSource();
         const fetchRequestStopWatch = new stopwatch_1.StopWatch();
         let responseSoFar = '';
-        let chatResponseFailure;
         let ttft;
         const firstTokenReceived = new async_2.DeferredPromise();
-        logContext.setHeaderRequestId(request.headerRequestId);
-        telemetryBuilder.setFetchStartedAt();
+        logContext.setHeaderRequestId(requestId);
+        telemetry.setFetchStartedAt();
         logContext.setFetchStartTime();
         // we must not await this promise because we want to stream edits as they come in
         const fetchResultPromise = endpoint.makeChatRequest2({
@@ -504,48 +566,51 @@ let XtabProvider = class XtabProvider {
             },
             userInitiatedRequest: undefined,
             telemetryProperties: {
-                requestId: request.headerRequestId,
+                requestId,
             },
             useFetcher,
             customMetadata: {
-                aggressivenessLevel: opts.aggressivenessLevel,
-                userHappinessScore: opts.userHappinessScore,
+                aggressivenessLevel: fetchMetadata.aggressivenessLevel,
+                userHappinessScore: fetchMetadata.userHappinessScore,
             },
-        }, cancellationToken);
-        telemetryBuilder.setResponse(fetchResultPromise.then((response) => ({ response, ttft })));
+        }, fetchCancellationToken);
+        telemetry.setResponse(fetchResultPromise.then((response) => ({ response, ttft })));
         logContext.setFullResponse(fetchResultPromise.then((response) => response.type === commonTypes_1.ChatFetchResponseType.Success ? response.value : undefined));
-        const fetchRes = await Promise.race([firstTokenReceived.p, fetchResultPromise]);
-        if (fetchRes && fetchRes.type !== commonTypes_1.ChatFetchResponseType.Success) {
-            if (fetchRes.type === commonTypes_1.ChatFetchResponseType.NotFound &&
-                !this.forceUseDefaultModel // if we haven't already forced using the default model; otherwise, this could cause an infinite loop
-            ) {
-                this.forceUseDefaultModel = true;
-                return yield* this.doGetNextEdit(request, delaySession, tracer, logContext, cancellationToken, telemetryBuilder, opts.retryState); // use the same retry state
-            }
-            // diff-patch based model returns no choices if it has no edits to suggest
-            if (fetchRes.type === commonTypes_1.ChatFetchResponseType.Unknown && fetchRes.reason === commonTypes_1.RESPONSE_CONTAINED_NO_CHOICES) {
-                return new statelessNextEditProvider_1.NoNextEditReason.NoSuggestions(request.documentBeforeEdits, editWindow);
-            }
-            return mapChatFetcherErrorToNoNextEditReason(fetchRes);
-        }
         fetchResultPromise
             .then((response) => {
-            // this's a way to signal the edit-pushing code to know if the request failed and
-            // 	it shouldn't push edits constructed from an erroneous response
-            chatResponseFailure = response.type !== commonTypes_1.ChatFetchResponseType.Success ? response : undefined;
+            if (response.type !== commonTypes_1.ChatFetchResponseType.Success) {
+                fetchStreamSource.reject(new fetchStreamError_1.FetchStreamError(mapChatFetcherErrorToNoNextEditReason(response)));
+            }
+            else {
+                fetchStreamSource.resolve();
+            }
         })
             .catch((err) => {
             // in principle this shouldn't happen because ChatMLFetcher's fetchOne should not throw
             logContext.setError(errors_1.ErrorUtils.fromUnknown(err));
             logContext.addLog(`ChatMLFetcher fetch call threw -- this's UNEXPECTED!`);
+            fetchStreamSource.reject(errors_1.ErrorUtils.fromUnknown(err));
         }).finally(() => {
             logContext.setFetchEndTime();
             if (!firstTokenReceived.isSettled) {
                 firstTokenReceived.complete();
             }
-            fetchStreamSource.resolve();
             logContext.setResponse(responseSoFar);
         });
+        const fetchRes = await Promise.race([firstTokenReceived.p, fetchResultPromise]);
+        if (fetchRes && fetchRes.type !== commonTypes_1.ChatFetchResponseType.Success) {
+            if (fetchRes.type === commonTypes_1.ChatFetchResponseType.NotFound &&
+                !this.forceUseDefaultModel // if we haven't already forced using the default model; otherwise, this could cause an infinite loop
+            ) {
+                this.forceUseDefaultModel = true;
+                return FetchResult.ModelNotFound.INSTANCE;
+            }
+            // diff-patch based model returns no choices if it has no edits to suggest
+            if (fetchRes.type === commonTypes_1.ChatFetchResponseType.Unknown && fetchRes.reason === commonTypes_1.RESPONSE_CONTAINED_NO_CHOICES) {
+                return new FetchResult.FetchFailure(new statelessNextEditProvider_1.NoNextEditReason.NoSuggestions(documentBeforeEdits, editWindow));
+            }
+            return new FetchResult.FetchFailure(mapChatFetcherErrorToNoNextEditReason(fetchRes));
+        }
         const llmLinesStream = asyncIterableUtils_1.AsyncIterUtilsExt.splitLines(asyncIterableUtils_1.AsyncIterUtils.map(fetchStreamSource.stream, (chunk) => chunk.delta.text));
         // logging of times
         // removal of cursor tag if option is set
@@ -554,119 +619,132 @@ let XtabProvider = class XtabProvider {
             for await (const v of llmLinesStream) {
                 const trace = `Line ${i++} emitted with latency ${fetchRequestStopWatch.elapsed()} ms`;
                 tracer.trace(trace);
-                yield opts.shouldRemoveCursorTagFromResponse
+                yield shouldRemoveCursorTagFromResponse
                     ? v.replaceAll(tags_1.PromptTags.CURSOR, '')
                     : v;
             }
         })();
-        const isFromCursorJump = opts.retryState instanceof RetryState.Retrying && opts.retryState.reason === 'cursorJump';
-        let cleanedLinesStream;
-        if (opts.responseFormat === xtabPromptOptions.ResponseFormat.EditWindowOnly) {
-            cleanedLinesStream = linesStream;
-        }
-        else if (opts.responseFormat === xtabPromptOptions.ResponseFormat.EditWindowWithEditIntent ||
-            opts.responseFormat === xtabPromptOptions.ResponseFormat.EditWindowWithEditIntentShort) {
-            // Determine parse mode based on response format
-            const parseMode = opts.responseFormat === xtabPromptOptions.ResponseFormat.EditWindowWithEditIntentShort
-                ? EditIntentParseMode.ShortName
-                : EditIntentParseMode.Tags;
-            // Parse the edit_intent from the response
-            const { editIntent, remainingLinesStream, parseError } = await parseEditIntentFromStream(linesStream, tracer, parseMode);
-            // Log the edit intent for telemetry
-            telemetryBuilder.setEditIntent(editIntent);
-            // Log parse errors for telemetry - this helps detect malformed model output during flights
-            if (parseError) {
-                telemetryBuilder.setEditIntentParseError(parseError);
-            }
-            // Check if we should show this edit based on intent and aggressiveness
-            if (!xtabPromptOptions.EditIntent.shouldShowEdit(editIntent, promptPieces.aggressivenessLevel)) {
-                tracer.trace(`Filtered out edit due to edit intent "${editIntent}" with aggressiveness "${promptPieces.aggressivenessLevel}"`);
-                return new statelessNextEditProvider_1.NoNextEditReason.FilteredOut(`editIntent:${editIntent} aggressivenessLevel:${promptPieces.aggressivenessLevel}`);
-            }
-            cleanedLinesStream = remainingLinesStream;
-        }
-        else if (opts.responseFormat === xtabPromptOptions.ResponseFormat.CustomDiffPatch) {
-            const activeDoc = request.getActiveDocument();
-            const currentDocument = promptPieces.currentDocument;
-            const lastLine = currentDocument.lines[clippedTaggedCurrentDoc.keptRange.endExclusive - 1];
-            const lastLineLength = lastLine.length;
-            const pseudoEditWindow = currentDocument.transformer.getOffsetRange(new range_1.Range(clippedTaggedCurrentDoc.keptRange.start + 1, 1, clippedTaggedCurrentDoc.keptRange.endExclusive, lastLineLength + 1));
-            return yield* xtabCustomDiffPatchResponseHandler_1.XtabCustomDiffPatchResponseHandler.handleResponse(linesStream, currentDocument, activeDoc.id, activeDoc.workspaceRoot, pseudoEditWindow, tracer, () => chatResponseFailure ? mapChatFetcherErrorToNoNextEditReason(chatResponseFailure) : undefined);
-        }
-        else if (opts.responseFormat === xtabPromptOptions.ResponseFormat.UnifiedWithXml) {
-            const linesIter = linesStream[Symbol.asyncIterator]();
-            const firstLine = await linesIter.next();
-            if (chatResponseFailure !== undefined) { // handle fetch failure
-                return new statelessNextEditProvider_1.NoNextEditReason.Unexpected(errors_1.ErrorUtils.fromUnknown(chatResponseFailure));
+        return new FetchResult.Lines(linesStream, () => responseSoFar, fetchRequestStopWatch);
+    }
+    async *_streamEditsImpl(request, editStreamCtx, responseOpts, fetchMetadata, retryState, delaySession, tracing, cancellationToken, fetchCts, fetchCancellationToken) {
+        const { tracer, logContext, telemetry } = tracing;
+        const { endpoint, messages, clippedTaggedCurrentDoc, editWindowInfo, promptPieces, prediction, originalEditWindow } = editStreamCtx;
+        const { editWindow, editWindowLines, cursorOriginalLinesOffset, editWindowLineRange } = editWindowInfo;
+        const targetDocument = request.getActiveDocument().id;
+        // Phase 1: Fetch lifecycle — initiate HTTP request and produce a clean line stream
+        const fetchResult = await this._performFetch(endpoint, messages, prediction, request.headerRequestId, fetchMetadata, responseOpts.shouldRemoveCursorTagFromResponse, editWindow, request.documentBeforeEdits, fetchCancellationToken, tracing);
+        if (fetchResult instanceof FetchResult.ModelNotFound) {
+            return yield* this.doGetNextEdit(request, delaySession, tracing, cancellationToken, retryState);
+        }
+        if (fetchResult instanceof FetchResult.FetchFailure) {
+            return fetchResult.reason;
+        }
+        const { linesStream, getResponseSoFar, fetchRequestStopWatch } = fetchResult;
+        // Phase 2: Dispatch to the appropriate response format handler
+        const isFromCursorJump = retryState instanceof RetryState.Retrying && retryState.reason === 'cursorJump';
+        let parseResult;
+        try {
+            switch (responseOpts.responseFormat) {
+                case xtabPromptOptions.ResponseFormat.EditWindowOnly: {
+                    parseResult = (0, responseFormatHandlers_1.handleEditWindowOnly)(linesStream);
+                    break;
+                }
+                case xtabPromptOptions.ResponseFormat.CodeBlock: {
+                    parseResult = (0, responseFormatHandlers_1.handleCodeBlock)(linesStream);
+                    break;
+                }
+                case xtabPromptOptions.ResponseFormat.EditWindowWithEditIntent:
+                case xtabPromptOptions.ResponseFormat.EditWindowWithEditIntentShort: {
+                    const parseMode = responseOpts.responseFormat === xtabPromptOptions.ResponseFormat.EditWindowWithEditIntentShort
+                        ? editIntent_1.EditIntentParseMode.ShortName
+                        : editIntent_1.EditIntentParseMode.Tags;
+                    parseResult = await (0, responseFormatHandlers_1.handleEditWindowWithEditIntent)(linesStream, tracer, parseMode);
+                    break;
+                }
+                case xtabPromptOptions.ResponseFormat.CustomDiffPatch: {
+                    const activeDoc = request.getActiveDocument();
+                    const currentDocument = promptPieces.currentDocument;
+                    const lastLine = currentDocument.lines[clippedTaggedCurrentDoc.keptRange.endExclusive - 1];
+                    const lastLineLength = lastLine.length;
+                    const pseudoEditWindow = currentDocument.transformer.getOffsetRange(new range_1.Range(clippedTaggedCurrentDoc.keptRange.start + 1, 1, clippedTaggedCurrentDoc.keptRange.endExclusive, lastLineLength + 1));
+                    parseResult = new responseFormatHandlers_1.ResponseParseResult.DirectEdits(xtabCustomDiffPatchResponseHandler_1.XtabCustomDiffPatchResponseHandler.handleResponse(linesStream, currentDocument, activeDoc.id, activeDoc.workspaceRoot, pseudoEditWindow, tracer));
+                    break;
+                }
+                case xtabPromptOptions.ResponseFormat.UnifiedWithXml: {
+                    parseResult = await (0, responseFormatHandlers_1.handleUnifiedWithXml)(linesStream, {
+                        editWindowLines,
+                        editWindowLineRange,
+                        cursorOriginalLinesOffset,
+                        cursorColumnZeroBased: promptPieces.currentDocument.cursorPosition.column - 1,
+                        editWindow,
+                        originalEditWindow,
+                        targetDocument,
+                        isFromCursorJump,
+                    }, request.documentBeforeEdits, tracer);
+                    break;
+                }
+                default:
+                    (0, assert_1.assertNever)(responseOpts.responseFormat);
             }
-            if (firstLine.done) { // no lines in response -- unexpected case but take as no suggestions
-                return new statelessNextEditProvider_1.NoNextEditReason.NoSuggestions(request.documentBeforeEdits, editWindow);
+            // Handle result uniformly
+            if (parseResult instanceof responseFormatHandlers_1.ResponseParseResult.Done) {
+                return parseResult.reason;
             }
-            const trimmedLines = firstLine.value.trim();
-            if (trimmedLines === tags_1.ResponseTags.NO_CHANGE.start) {
-                return yield* this.doGetNextEditsWithCursorJump(request, modelServiceConfig, editWindow, promptPieces, delaySession, tracer, logContext, cancellationToken, telemetryBuilder, opts.retryState);
+            if (parseResult instanceof responseFormatHandlers_1.ResponseParseResult.DirectEdits) {
+                return yield* parseResult.stream;
             }
-            if (trimmedLines === tags_1.ResponseTags.INSERT.start) {
-                const lineWithCursorContinued = await linesIter.next();
-                if (lineWithCursorContinued.done || lineWithCursorContinued.value.includes(tags_1.ResponseTags.INSERT.end)) {
-                    return new statelessNextEditProvider_1.NoNextEditReason.NoSuggestions(request.documentBeforeEdits, editWindow);
+            // parseResult is EditWindowLines — log edit-intent telemetry and apply aggressiveness filter
+            if (parseResult.editIntentMetadata) {
+                const { intent, parseError } = parseResult.editIntentMetadata;
+                telemetry.setEditIntent(intent);
+                if (parseError) {
+                    telemetry.setEditIntentParseError(parseError);
                 }
-                const cursorColumnOffsetZeroBased = promptPieces.currentDocument.cursorPosition.column - 1;
-                const edit = new lineEdit_1.LineReplacement(new lineRange_1.LineRange(editWindowLineRange.start + cursorOriginalLinesOffset + 1 /* 0-based to 1-based */, editWindowLineRange.start + cursorOriginalLinesOffset + 2), [editWindowLines[cursorOriginalLinesOffset].slice(0, cursorColumnOffsetZeroBased) + lineWithCursorContinued.value + editWindowLines[cursorOriginalLinesOffset].slice(cursorColumnOffsetZeroBased)]);
-                yield { edit, isFromCursorJump, window: editWindow, originalWindow: originalEditWindow, targetDocument };
-                const lines = [];
-                let v = await linesIter.next();
-                while (!v.done) {
-                    if (v.value.includes(tags_1.ResponseTags.INSERT.end)) {
-                        break;
-                    }
-                    else {
-                        lines.push(v.value);
-                    }
-                    v = await linesIter.next();
+                if (!xtabPromptOptions.EditIntent.shouldShowEdit(intent, promptPieces.aggressivenessLevel)) {
+                    tracer.trace(`Filtered out edit due to edit intent "${intent}" with aggressiveness "${promptPieces.aggressivenessLevel}"`);
+                    return new statelessNextEditProvider_1.NoNextEditReason.FilteredOut(`editIntent:${intent} aggressivenessLevel:${promptPieces.aggressivenessLevel}`);
                 }
-                const line = editWindowLineRange.start + cursorOriginalLinesOffset + 2;
-                yield {
-                    edit: new lineEdit_1.LineReplacement(new lineRange_1.LineRange(line, line), lines),
-                    isFromCursorJump,
-                    window: editWindow,
-                    originalWindow: originalEditWindow,
-                    targetDocument,
-                };
-                return new statelessNextEditProvider_1.NoNextEditReason.NoSuggestions(request.documentBeforeEdits, editWindow);
             }
-            if (trimmedLines === tags_1.ResponseTags.EDIT.start) {
-                cleanedLinesStream = (async function* () {
-                    let v = await linesIter.next();
-                    while (!v.done) {
-                        if (v.value.includes(tags_1.ResponseTags.EDIT.end)) {
-                            return;
-                        }
-                        yield v.value;
-                        v = await linesIter.next();
-                    }
-                })();
-            }
-            else {
-                return new statelessNextEditProvider_1.NoNextEditReason.Unexpected(new Error(`unexpected tag ${trimmedLines}`));
-            }
-        }
-        else if (opts.responseFormat === xtabPromptOptions.ResponseFormat.CodeBlock) {
-            cleanedLinesStream = (0, xtabUtils_1.linesWithBackticksRemoved)(linesStream);
-        }
-        else {
-            (0, assert_1.assertNever)(opts.responseFormat);
-        }
-        const diffOptions = {
-            emitFastCursorLineChange: responseProcessor_1.ResponseProcessor.mapEmitFastCursorLineChange(this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.TeamInternal.InlineEditsXtabProviderEmitFastCursorLineChange, this.expService)),
-            nLinesToConverge: this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.TeamInternal.InlineEditsXtabNNonSignificantLinesToConverge, this.expService),
-            nSignificantLinesToConverge: this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.TeamInternal.InlineEditsXtabNSignificantLinesToConverge, this.expService),
-        };
-        tracer.trace(`starting to diff stream against edit window lines with latency ${fetchRequestStopWatch.elapsed()} ms`);
-        let i = 0;
-        let hasBeenDelayed = false;
-        try {
-            for await (const edit of responseProcessor_1.ResponseProcessor.diff(editWindowLines, cleanedLinesStream, cursorOriginalLinesOffset, diffOptions)) {
+            const cleanedLinesStream = parseResult.lines;
+            const diffOptions = {
+                emitFastCursorLineChange: responseProcessor_1.ResponseProcessor.mapEmitFastCursorLineChange(this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.TeamInternal.InlineEditsXtabProviderEmitFastCursorLineChange, this.expService)),
+                nLinesToConverge: this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.TeamInternal.InlineEditsXtabNNonSignificantLinesToConverge, this.expService),
+                nSignificantLinesToConverge: this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.TeamInternal.InlineEditsXtabNSignificantLinesToConverge, this.expService),
+            };
+            tracer.trace(`starting to diff stream against edit window lines with latency ${fetchRequestStopWatch.elapsed()} ms`);
+            // Wrap the line stream to detect early divergence between the user's
+            // intermediate edits and the model's streamed output.
+            // In `Cursor` mode only the cursor line is checked; in `EditWindow`
+            // mode every line in the edit window is checked.
+            //
+            // We check compatibility using `isModelLineCompatible`: the user's
+            // line change must be contained within the model's line change range
+            // and match via the helper's `startsWith` / auto-close subsequence rules.
+            const earlyDivergenceMode = (0, backwardCompatSetting_1.backwardCompatSetting)(this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.TeamInternal.InlineEditsXtabEarlyCursorLineDivergenceCancellation, this.expService), (value) => {
+                switch (value) {
+                    case false:
+                    case undefined:
+                        return xtabPromptOptions_1.EarlyDivergenceCancellationMode.Off;
+                    case true:
+                        return xtabPromptOptions_1.EarlyDivergenceCancellationMode.Cursor;
+                    case xtabPromptOptions_1.EarlyDivergenceCancellationMode.Off:
+                    case xtabPromptOptions_1.EarlyDivergenceCancellationMode.Cursor:
+                    case xtabPromptOptions_1.EarlyDivergenceCancellationMode.EditWindow:
+                        return value;
+                    default:
+                        return xtabPromptOptions_1.EarlyDivergenceCancellationMode.Off;
+                }
+            });
+            let lineDiverged = false;
+            const divergenceCheckedStream = earlyDivergenceMode === xtabPromptOptions_1.EarlyDivergenceCancellationMode.Off
+                ? cleanedLinesStream
+                : linesWithIntermediateEditDivergenceCheck(cleanedLinesStream, cursorOriginalLinesOffset, request, editWindowLineRange, editWindowLines, fetchCts, tracing, (value) => { lineDiverged = value; }, earlyDivergenceMode);
+            let i = 0;
+            let hasBeenDelayed = false;
+            for await (const edit of responseProcessor_1.ResponseProcessor.diff(editWindowLines, divergenceCheckedStream, cursorOriginalLinesOffset, diffOptions)) {
+                if (lineDiverged) {
+                    break;
+                }
                 tracer.trace(`ResponseProcessor streamed edit #${i} with latency ${fetchRequestStopWatch.elapsed()} ms`);
                 const singleLineEdits = [];
                 if (edit.lineRange.startLineNumber === edit.lineRange.endLineNumberExclusive || // we don't want to run diff on insertion
@@ -690,15 +768,12 @@ let XtabProvider = class XtabProvider {
                         singleLineEdits.push(singleLineEdit);
                     }
                 }
-                if (chatResponseFailure) { // do not emit edits if chat response failed
-                    break;
-                }
-                logContext.setResponse(responseSoFar);
+                logContext.setResponse(getResponseSoFar());
                 for (const singleLineEdit of singleLineEdits) {
                     tracer.trace(`extracting edit #${i}: ${singleLineEdit.toString()}`);
                     if (!hasBeenDelayed) { // delay only the first one
                         hasBeenDelayed = true;
-                        const artificialDelay = this.determineArtificialDelayMs(delaySession, tracer, telemetryBuilder);
+                        const artificialDelay = this.determineArtificialDelayMs(delaySession, tracer, telemetry);
                         if (artificialDelay) {
                             await (0, async_2.timeout)(artificialDelay);
                             tracer.trace(`Artificial delay of ${artificialDelay} ms completed`);
@@ -711,20 +786,24 @@ let XtabProvider = class XtabProvider {
                     i++;
                 }
             }
-            if (chatResponseFailure) {
-                return mapChatFetcherErrorToNoNextEditReason(chatResponseFailure);
+            if (lineDiverged) {
+                return new statelessNextEditProvider_1.NoNextEditReason.GotCancelled(earlyDivergenceMode === xtabPromptOptions_1.EarlyDivergenceCancellationMode.Cursor ? 'cursorLineDiverged' : 'editWindowLineDiverged');
             }
             return new statelessNextEditProvider_1.NoNextEditReason.NoSuggestions(request.documentBeforeEdits, editWindow);
         }
         catch (err) {
+            if (err instanceof fetchStreamError_1.FetchStreamError) {
+                return err.reason;
+            }
             logContext.setError(err);
-            // Properly handle the error by pushing it as a result
             return new statelessNextEditProvider_1.NoNextEditReason.Unexpected(errors_1.ErrorUtils.fromUnknown(err));
         }
     }
-    async *doGetNextEditsWithCursorJump(request, modelConfig, editWindow, promptPieces, delaySession, tracer, logContext, cancellationToken, telemetryBuilder, retryState) {
+    async *doGetNextEditsWithCursorJump(request, editStreamCtx, delaySession, tracing, cancellationToken, retryState) {
+        const { tracer, telemetry } = tracing;
+        const { editWindowInfo: { editWindow }, modelServiceConfig, promptPieces } = editStreamCtx;
         const noSuggestions = new statelessNextEditProvider_1.NoNextEditReason.NoSuggestions(request.documentBeforeEdits, editWindow);
-        const nextCursorLinePrediction = this.nextCursorPredictor.determineEnablement(modelConfig.supportsNextCursorLinePrediction);
+        const nextCursorLinePrediction = this.nextCursorPredictor.determineEnablement(modelServiceConfig.supportsNextCursorLinePrediction);
         if (nextCursorLinePrediction === undefined || retryState instanceof RetryState.Retrying) {
             return noSuggestions;
         }
@@ -732,7 +811,7 @@ let XtabProvider = class XtabProvider {
             tracer.trace('Skipping cursor prediction: user typed during request');
             return new statelessNextEditProvider_1.NoNextEditReason.GotCancelled('beforeNextCursorPredictionFetchUserTyped');
         }
-        const nextCursorLineR = await this.nextCursorPredictor.predictNextCursorPosition(promptPieces, tracer, telemetryBuilder, cancellationToken);
+        const nextCursorLineR = await this.nextCursorPredictor.predictNextCursorPosition(promptPieces, tracer, telemetry, cancellationToken);
         if (cancellationToken.isCancellationRequested) {
             return new statelessNextEditProvider_1.NoNextEditReason.GotCancelled('afterNextCursorPredictionFetch');
         }
@@ -742,26 +821,26 @@ let XtabProvider = class XtabProvider {
         }
         if (nextCursorLineR.isError()) {
             tracer.trace(`Predicted next cursor line error: ${nextCursorLineR.err.message}`);
-            telemetryBuilder.setNextCursorLineError(nextCursorLineR.err.message);
+            telemetry.setNextCursorLineError(nextCursorLineR.err.message);
             return noSuggestions;
         }
         const prediction = nextCursorLineR.val;
         if (prediction.kind === 'differentFile') {
-            return yield* this.handleCrossFilePrediction(prediction, nextCursorLinePrediction, request, editWindow, promptPieces, delaySession, tracer, logContext, cancellationToken, telemetryBuilder);
+            return yield* this.handleCrossFilePrediction(prediction, nextCursorLinePrediction, request, editStreamCtx, delaySession, tracing, cancellationToken);
         }
         const nextCursorLineZeroBased = prediction.lineNumber;
         const lineDistanceFromCursorLine = nextCursorLineZeroBased - promptPieces.currentDocument.cursorLineOffset;
-        telemetryBuilder.setNextCursorLineDistance(lineDistanceFromCursorLine);
-        telemetryBuilder.setNextCursorIsCrossFile(false);
+        telemetry.setNextCursorLineDistance(lineDistanceFromCursorLine);
+        telemetry.setNextCursorIsCrossFile(false);
         tracer.trace(`Predicted next cursor line: ${nextCursorLineZeroBased}`);
         if (nextCursorLineZeroBased >= promptPieces.currentDocument.lines.length) { // >= because the line index is zero-based
             tracer.trace(`Predicted next cursor line error: exceedsDocumentLines`);
-            telemetryBuilder.setNextCursorLineError('exceedsDocumentLines');
+            telemetry.setNextCursorLineError('exceedsDocumentLines');
             return noSuggestions;
         }
         if (promptPieces.editWindowLinesRange.contains(nextCursorLineZeroBased)) {
             tracer.trace(`Predicted next cursor line error: withinEditWindow`);
-            telemetryBuilder.setNextCursorLineError('withinEditWindow');
+            telemetry.setNextCursorLineError('withinEditWindow');
             return noSuggestions;
         }
         const nextCursorLineOneBased = nextCursorLineZeroBased + 1;
@@ -774,7 +853,7 @@ let XtabProvider = class XtabProvider {
                 return new statelessNextEditProvider_1.NoNextEditReason.NoSuggestions(request.documentBeforeEdits, editWindow, nextCursorPosition);
             }
             case nextCursorLinePrediction_1.NextCursorLinePrediction.OnlyWithEdit: {
-                const v = this.doGetNextEditWithSelection(request, new range_1.Range(nextCursorLineOneBased, nextCursorColumn, nextCursorLineOneBased, nextCursorColumn), delaySession, tracer, logContext, cancellationToken, telemetryBuilder, new RetryState.Retrying('cursorJump'), editWindow);
+                const v = this.doGetNextEditWithSelection(request, new range_1.Range(nextCursorLineOneBased, nextCursorColumn, nextCursorLineOneBased, nextCursorColumn), delaySession, tracing, cancellationToken, new RetryState.Retrying('cursorJump'), editWindow);
                 return yield* v;
             }
             default: {
@@ -782,11 +861,13 @@ let XtabProvider = class XtabProvider {
             }
         }
     }
-    async *handleCrossFilePrediction(prediction, nextCursorLinePrediction, request, editWindow, promptPieces, delaySession, tracer, logContext, cancellationToken, telemetryBuilder) {
+    async *handleCrossFilePrediction(prediction, nextCursorLinePrediction, request, editStreamCtx, delaySession, tracing, cancellationToken) {
+        const { tracer, telemetry } = tracing;
+        const { editWindowInfo: { editWindow }, promptPieces } = editStreamCtx;
         const workspaceRoot = promptPieces.activeDoc.workspaceRoot;
         if (!workspaceRoot && !(0, path_1.isAbsolute)(prediction.filePath)) {
             tracer.trace('Predicted cross-file cursor jump error: noWorkspaceRoot');
-            telemetryBuilder.setNextCursorLineError('crossFile:noWorkspaceRoot');
+            telemetry.setNextCursorLineError('crossFile:noWorkspaceRoot');
             return new statelessNextEditProvider_1.NoNextEditReason.NoSuggestions(request.documentBeforeEdits, editWindow);
         }
         const targetUri = (0, path_1.isAbsolute)(prediction.filePath)
@@ -795,7 +876,7 @@ let XtabProvider = class XtabProvider {
         const targetDocumentId = documentId_1.DocumentId.create(targetUri.toString());
         const nextCursorLineOneBased = prediction.lineNumber + 1;
         const nextCursorPosition = new position_1.Position(nextCursorLineOneBased, 1);
-        telemetryBuilder.setNextCursorIsCrossFile(true);
+        telemetry.setNextCursorIsCrossFile(true);
         tracer.trace(`Predicted cross-file cursor jump: ${prediction.filePath}:${prediction.lineNumber}`);
         switch (nextCursorLinePrediction) {
             case nextCursorLinePrediction_1.NextCursorLinePrediction.Jump: {
@@ -808,7 +889,7 @@ let XtabProvider = class XtabProvider {
                 }
                 catch (err) {
                     tracer.trace(`Failed to open target file for cross-file edit: ${errors_1.ErrorUtils.fromUnknown(err).message}`);
-                    telemetryBuilder.setNextCursorLineError('crossFile:failedToOpenFile');
+                    telemetry.setNextCursorLineError('crossFile:failedToOpenFile');
                     return new statelessNextEditProvider_1.NoNextEditReason.NoSuggestions(request.documentBeforeEdits, editWindow, nextCursorPosition, targetDocumentId);
                 }
                 if (cancellationToken.isCancellationRequested) {
@@ -821,7 +902,7 @@ let XtabProvider = class XtabProvider {
                 const targetContent = new abstractText_1.StringText(targetTextDoc.getText());
                 const syntheticDoc = new statelessNextEditProvider_1.StatelessNextEditDocument(targetDocumentId, promptPieces.activeDoc.workspaceRoot, languageId_1.LanguageId.create(targetTextDoc.languageId), targetContent.getLines(), lineEdit_1.LineEdit.empty, targetContent, new edit_1.Edits(stringEdit_1.StringEdit, []));
                 const syntheticRequest = new statelessNextEditProvider_1.StatelessNextEditRequest(request.headerRequestId, request.opportunityId, targetContent, [syntheticDoc], 0, request.xtabEditHistory, new async_2.DeferredPromise(), request.expandedEditWindowNLines, request.isSpeculative, request.logContext, request.recordingBookmark, request.recording, request.providerRequestStartDateTime);
-                return yield* this.doGetNextEditWithSelection(syntheticRequest, new range_1.Range(nextCursorLineOneBased, 1, nextCursorLineOneBased, 1), delaySession, tracer, logContext, cancellationToken, telemetryBuilder, new RetryState.Retrying('cursorJump'), editWindow);
+                return yield* this.doGetNextEditWithSelection(syntheticRequest, new range_1.Range(nextCursorLineOneBased, 1, nextCursorLineOneBased, 1), delaySession, tracing, cancellationToken, new RetryState.Retrying('cursorJump'), editWindow);
             }
             default: {
                 (0, assert_1.assertNever)(nextCursorLinePrediction);
@@ -873,7 +954,7 @@ let XtabProvider = class XtabProvider {
         const maxMergeConflictLines = this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.TeamInternal.InlineEditsXtabMaxMergeConflictLines, this.expService);
         if (maxMergeConflictLines) {
             const tentativeEditWindow = new offsetRange_1.OffsetRange(codeToEditStart, codeToEditEndExcl);
-            const mergeConflictRange = findMergeConflictMarkersRange(currentDocLines, tentativeEditWindow, maxMergeConflictLines);
+            const mergeConflictRange = (0, xtabUtils_1.findMergeConflictMarkersRange)(currentDocLines, tentativeEditWindow, maxMergeConflictLines);
             if (mergeConflictRange) {
                 const onlyMergeConflictLines = this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.TeamInternal.InlineEditsXtabOnlyMergeConflictLines, this.expService);
                 telemetry.setMergeConflictExpanded(onlyMergeConflictLines ? 'only' : 'normal');
@@ -1191,176 +1272,49 @@ function getPredictionContents(doc, editWindowLines, responseFormat) {
         (0, assert_1.assertNever)(responseFormat);
     }
 }
-/**
- * Mode for parsing edit intent from the model response.
- */
-var EditIntentParseMode;
-(function (EditIntentParseMode) {
-    /** Parse using XML-style tags: <|edit_intent|>value<|/edit_intent|> */
-    EditIntentParseMode["Tags"] = "tags";
-    /** Parse using short names on the first line: N|L|M|H */
-    EditIntentParseMode["ShortName"] = "shortName";
-})(EditIntentParseMode || (exports.EditIntentParseMode = EditIntentParseMode = {}));
-/**
- * Parses the edit_intent from the first line of the response stream.
- * The edit_intent MUST be on the first line, otherwise it's treated as not provided.
- * Returns the parsed EditIntent and a new stream with the remaining content.
- *
- * Supports two modes:
- * - Tags (default): <|edit_intent|>low|medium|high|no_edit<|/edit_intent|>
- * - ShortName: N|L|M|H on the first line
- *
- * @param linesStream The stream of lines from the model response
- * @param tracer Logger for tracing
- * @param mode The parse mode (Tags or ShortName), defaults to Tags
- */
-async function parseEditIntentFromStream(linesStream, tracer, mode = EditIntentParseMode.Tags) {
-    if (mode === EditIntentParseMode.ShortName) {
-        return parseEditIntentFromStreamShortName(linesStream, tracer);
-    }
-    return parseEditIntentFromStreamTags(linesStream, tracer);
-}
-/**
- * Parses the edit_intent using short name format (N|L|M|H on first line).
- */
-async function parseEditIntentFromStreamShortName(linesStream, tracer) {
-    let editIntent = xtabPromptOptions.EditIntent.High; // Default to high (always show) if no short name found
-    let parseError;
-    const linesIter = linesStream[Symbol.asyncIterator]();
-    const firstLineResult = await linesIter.next();
-    if (firstLineResult.done) {
-        // Empty stream
-        parseError = 'emptyResponse';
-        tracer.warn(`Empty response stream, no edit_intent short name found`);
-        const remainingLinesStream = (async function* () { })();
-        return { editIntent, remainingLinesStream, parseError };
-    }
-    const firstLine = firstLineResult.value.trim();
-    // Check if the first line is a single character short name
-    const parsedIntent = xtabPromptOptions.EditIntent.fromShortName(firstLine);
-    if (parsedIntent !== undefined) {
-        editIntent = parsedIntent;
-        tracer.trace(`Parsed edit_intent short name from first line: "${firstLine}" -> ${editIntent}`);
-        // Create a new stream with the remaining lines (excluding the short name line)
-        const remainingLinesStream = (async function* () {
-            let next = await linesIter.next();
-            while (!next.done) {
-                yield next.value;
-                next = await linesIter.next();
-            }
-        })();
-        return { editIntent, remainingLinesStream, parseError };
+async function* linesWithIntermediateEditDivergenceCheck(cleanedLinesStream, cursorOriginalLinesOffset, request, editWindowLineRange, editWindowLines, fetchCts, { tracer }, setLineDiverged, mode) {
+    const intermediateEdit = request.intermediateUserEdit;
+    if (!intermediateEdit || intermediateEdit.isEmpty()) {
+        yield* cleanedLinesStream;
+        return;
     }
-    // Short name not found or invalid
-    parseError = `unknownIntentValue:${firstLine}`;
-    tracer.warn(`Edit intent parse error: ${parseError} (using Xtab275EditIntentShort prompting strategy). ` +
-        `Defaulting to High (always show). First line was: "${firstLine.substring(0, 100)}..."`);
-    // Return the first line plus the rest of the stream
-    const remainingLinesStream = (async function* () {
-        yield firstLineResult.value; // Use original value, not trimmed
-        let next = await linesIter.next();
-        while (!next.done) {
-            yield next.value;
-            next = await linesIter.next();
+    const transformer = request.documentBeforeEdits.getTransformer();
+    // Precompute the post-edit document once to avoid O(lines * docSize) in EditWindow mode.
+    const currentDoc = intermediateEdit.apply(transformer.text);
+    const currentTransformer = new positionToOffset_1.PositionOffsetTransformer(currentDoc);
+    const precomputed = { currentDoc, currentTransformer };
+    const shouldCheckLine = (lineIdx) => {
+        if (lineIdx >= editWindowLines.length) {
+            return false;
+        }
+        switch (mode) {
+            case xtabPromptOptions_1.EarlyDivergenceCancellationMode.Cursor:
+                return lineIdx === cursorOriginalLinesOffset;
+            case xtabPromptOptions_1.EarlyDivergenceCancellationMode.EditWindow:
+                return true;
         }
-    })();
-    return { editIntent, remainingLinesStream, parseError };
-}
-/**
- * Parses the edit_intent tag from the first line of the response stream (original tag-based format).
- */
-async function parseEditIntentFromStreamTags(linesStream, tracer) {
-    const EDIT_INTENT_START_TAG = '<|edit_intent|>';
-    const EDIT_INTENT_END_TAG = '<|/edit_intent|>';
-    let editIntent = xtabPromptOptions.EditIntent.High; // Default to high (always show) if no tag found
-    let parseError;
-    const linesIter = linesStream[Symbol.asyncIterator]();
-    const firstLineResult = await linesIter.next();
-    if (firstLineResult.done) {
-        // Empty stream
-        parseError = 'emptyResponse';
-        tracer.warn(`Empty response stream, no edit_intent tag found`);
-        const remainingLinesStream = (async function* () { })();
-        return { editIntent, remainingLinesStream, parseError };
-    }
-    const firstLine = firstLineResult.value;
-    // Check if the first line contains the complete edit_intent tag
-    const startIdx = firstLine.indexOf(EDIT_INTENT_START_TAG);
-    const endIdx = firstLine.indexOf(EDIT_INTENT_END_TAG);
-    if (startIdx !== -1 && endIdx !== -1 && endIdx > startIdx) {
-        // Found complete tag on first line
-        const intentValue = firstLine.substring(startIdx + EDIT_INTENT_START_TAG.length, endIdx).trim().toLowerCase();
-        // Check if it's a known intent value
-        const knownIntentValues = ['no_edit', 'low', 'medium', 'high'];
-        if (!knownIntentValues.includes(intentValue)) {
-            parseError = `unknownIntentValue:${intentValue}`;
-            tracer.warn(`Unknown edit_intent value: "${intentValue}", defaulting to High`);
-        }
-        editIntent = xtabPromptOptions.EditIntent.fromString(intentValue);
-        tracer.trace(`Parsed edit_intent from first line: "${intentValue}" -> ${editIntent}`);
-        // Calculate remaining content after the end tag on the first line
-        const afterEndTag = firstLine.substring(endIdx + EDIT_INTENT_END_TAG.length);
-        // Create a new stream that first yields remaining content from first line, then continues
-        const remainingLinesStream = (async function* () {
-            // Only yield remaining content from first line if non-empty
-            if (afterEndTag.trim() !== '') {
-                yield afterEndTag;
-            }
-            // Continue with rest of the stream
-            let next = await linesIter.next();
-            while (!next.done) {
-                yield next.value;
-                next = await linesIter.next();
-            }
-        })();
-        return { editIntent, remainingLinesStream, parseError };
-    }
-    // Determine the parse error type
-    if (startIdx !== -1 && endIdx === -1) {
-        // Start tag found but no end tag - malformed (possibly split across lines)
-        parseError = 'malformedTag:startWithoutEnd';
-    }
-    else if (startIdx === -1 && endIdx !== -1) {
-        // End tag found but no start tag - malformed
-        parseError = 'malformedTag:endWithoutStart';
-    }
-    else {
-        // No tag found at all
-        parseError = 'noTagFound';
-    }
-    tracer.warn(`Edit intent parse error: ${parseError} (using Xtab275EditIntent prompting strategy). ` +
-        `Defaulting to High (always show). First line was: "${firstLine.substring(0, 100)}..."`);
-    // Return the first line plus the rest of the stream
-    const remainingLinesStream = (async function* () {
-        yield firstLine;
-        let next = await linesIter.next();
-        while (!next.done) {
-            yield next.value;
-            next = await linesIter.next();
-        }
-    })();
-    return { editIntent, remainingLinesStream, parseError };
-}
-/**
- * Finds the range of lines containing merge conflict markers within a specified edit window.
- *
- * @param lines - Array of strings representing the lines of text to search through
- * @param editWindowRange - The range within which to search for merge conflict markers
- * @param maxMergeConflictLines - Maximum number of lines to search for conflict markers
- * @returns An OffsetRange object representing the start and end of the conflict markers, or undefined if not found
- */
-function findMergeConflictMarkersRange(lines, editWindowRange, maxMergeConflictLines) {
-    for (let i = editWindowRange.start; i < Math.min(lines.length, editWindowRange.endExclusive); ++i) {
-        if (!lines[i].startsWith('<<<<<<<')) {
-            continue;
-        }
-        // found start of merge conflict markers -- now find the end
-        for (let j = i + 1; j < lines.length && (j - i) < maxMergeConflictLines; ++j) {
-            if (lines[j].startsWith('>>>>>>>')) {
-                return new offsetRange_1.OffsetRange(i, j + 1 /* because endExclusive */);
+    };
+    let lineIdx = 0;
+    for await (const line of cleanedLinesStream) {
+        if (shouldCheckLine(lineIdx)) {
+            const docLineIdx = editWindowLineRange.start + lineIdx;
+            const currentLine = (0, cursorLineDivergence_1.getCurrentLine)(transformer, docLineIdx, intermediateEdit, precomputed);
+            if (currentLine !== undefined) {
+                const originalLine = editWindowLines[lineIdx];
+                if (currentLine !== originalLine // user changed this line
+                    && !(0, cursorLineDivergence_1.isModelLineCompatible)(originalLine, currentLine, line) // model's line isn't compatible with user's typing
+                ) {
+                    setLineDiverged(true);
+                    tracer.trace(`Line ${lineIdx} DIVERGED (mode=${mode}): model="${line}" current="${currentLine}"`);
+                    // Cancel our local fetch token so the HTTP request is
+                    // aborted immediately. We own this token, so this is safe.
+                    fetchCts.cancel();
+                    return;
+                }
             }
         }
+        yield line;
+        lineIdx++;
     }
-    return undefined;
 }
 //# sourceMappingURL=xtabProvider.js.map