@vscode/chat-lib 0.43.2026040705 → 0.44.1

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");
@@ -85,6 +83,7 @@ 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");
@@ -109,6 +108,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 +136,28 @@ var RetryState;
     }
     RetryState.Retrying = Retrying;
 })(RetryState || (RetryState = {}));
+var FetchResult;
+(function (FetchResult) {
+    class Lines {
+        constructor(linesStream, getFetchFailure, getResponseSoFar, fetchRequestStopWatch) {
+            this.linesStream = linesStream;
+            this.getFetchFailure = getFetchFailure;
+            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 +198,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 +220,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 +268,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 +294,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 +394,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 +412,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 +472,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,13 +500,35 @@ 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();
@@ -475,8 +536,8 @@ let XtabProvider = class XtabProvider {
         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,30 +565,16 @@ 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
@@ -546,6 +593,21 @@ let XtabProvider = class XtabProvider {
             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 getFetchFailure = () => chatResponseFailure ? mapChatFetcherErrorToNoNextEditReason(chatResponseFailure) : undefined;
         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 +616,150 @@ 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}`);
+        return new FetchResult.Lines(linesStream, getFetchFailure, () => 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, getFetchFailure, getResponseSoFar, fetchRequestStopWatch } = fetchResult;
+        // Phase 2: Dispatch to the appropriate response format handler
+        const isFromCursorJump = retryState instanceof RetryState.Retrying && retryState.reason === 'cursorJump';
+        let parseResult;
+        switch (responseOpts.responseFormat) {
+            case xtabPromptOptions.ResponseFormat.EditWindowOnly: {
+                parseResult = (0, responseFormatHandlers_1.handleEditWindowOnly)(linesStream);
+                break;
             }
-            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));
+            case xtabPromptOptions.ResponseFormat.CodeBlock: {
+                parseResult = (0, responseFormatHandlers_1.handleCodeBlock)(linesStream);
+                break;
             }
-            if (firstLine.done) { // no lines in response -- unexpected case but take as no suggestions
-                return new statelessNextEditProvider_1.NoNextEditReason.NoSuggestions(request.documentBeforeEdits, editWindow);
+            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, getFetchFailure);
+                break;
             }
-            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);
+            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, getFetchFailure));
+                break;
             }
-            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);
-                }
-                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();
-                }
-                const line = editWindowLineRange.start + cursorOriginalLinesOffset + 2;
-                yield {
-                    edit: new lineEdit_1.LineReplacement(new lineRange_1.LineRange(line, line), lines),
-                    isFromCursorJump,
-                    window: editWindow,
-                    originalWindow: originalEditWindow,
+            case xtabPromptOptions.ResponseFormat.UnifiedWithXml: {
+                parseResult = await (0, responseFormatHandlers_1.handleUnifiedWithXml)(linesStream, {
+                    editWindowLines,
+                    editWindowLineRange,
+                    cursorOriginalLinesOffset,
+                    cursorColumnZeroBased: promptPieces.currentDocument.cursorPosition.column - 1,
+                    editWindow,
+                    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}`));
+                    isFromCursorJump,
+                }, request.documentBeforeEdits, tracer, getFetchFailure);
+                break;
             }
+            default:
+                (0, assert_1.assertNever)(responseOpts.responseFormat);
         }
-        else if (opts.responseFormat === xtabPromptOptions.ResponseFormat.CodeBlock) {
-            cleanedLinesStream = (0, xtabUtils_1.linesWithBackticksRemoved)(linesStream);
+        // Handle result uniformly
+        if (parseResult instanceof responseFormatHandlers_1.ResponseParseResult.Done) {
+            return parseResult.reason;
         }
-        else {
-            (0, assert_1.assertNever)(opts.responseFormat);
+        if (parseResult instanceof responseFormatHandlers_1.ResponseParseResult.DirectEdits) {
+            return yield* parseResult.stream;
         }
+        // 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);
+            }
+            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 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 cursor-line divergence.
+        // If the user has typed at the cursor since the request started and the cursor line
+        // in the model's response doesn't match what the user currently has, the response
+        // is stale and we can cancel early instead of waiting for the full response.
+        //
+        // We check compatibility using `isModelCursorLineCompatible`: the user's
+        // cursor-line change must be contained within the model's cursor-line change range
+        // and match via the helper's `startsWith` / auto-close subsequence rules.
+        const earlyCursorLineDivergenceCancellation = this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.TeamInternal.InlineEditsXtabEarlyCursorLineDivergenceCancellation, this.expService);
+        let cursorLineDiverged = false;
+        const divergenceCheckedStream = earlyCursorLineDivergenceCancellation
+            ? (async function* () {
+                let lineIdx = 0;
+                for await (const line of cleanedLinesStream) {
+                    if (lineIdx === cursorOriginalLinesOffset) {
+                        const intermediateEdit = request.intermediateUserEdit;
+                        if (intermediateEdit && !intermediateEdit.isEmpty()) {
+                            const cursorDocLineIdx = editWindowLineRange.start + cursorOriginalLinesOffset;
+                            const currentCursorLine = (0, cursorLineDivergence_1.getCurrentCursorLine)(request.documentBeforeEdits.getTransformer(), cursorDocLineIdx, intermediateEdit);
+                            if (currentCursorLine !== undefined) {
+                                const originalCursorLine = editWindowLines[cursorOriginalLinesOffset];
+                                if (currentCursorLine !== originalCursorLine // user changed the cursor line
+                                    && !(0, cursorLineDivergence_1.isModelCursorLineCompatible)(originalCursorLine, currentCursorLine, line) // model's cursor line isn't compatible with user's typing
+                                ) {
+                                    cursorLineDiverged = true;
+                                    tracer.trace(`Cursor line DIVERGED: model="${line}" current="${currentCursorLine}"`);
+                                    // 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++;
+                }
+            })()
+            : cleanedLinesStream;
         let i = 0;
         let hasBeenDelayed = false;
         try {
-            for await (const edit of responseProcessor_1.ResponseProcessor.diff(editWindowLines, cleanedLinesStream, cursorOriginalLinesOffset, diffOptions)) {
+            for await (const edit of responseProcessor_1.ResponseProcessor.diff(editWindowLines, divergenceCheckedStream, cursorOriginalLinesOffset, diffOptions)) {
+                if (cursorLineDiverged) {
+                    break;
+                }
+                {
+                    const fetchFailure = getFetchFailure();
+                    if (fetchFailure) {
+                        return fetchFailure;
+                    }
+                }
                 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 +783,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,8 +801,14 @@ let XtabProvider = class XtabProvider {
                     i++;
                 }
             }
-            if (chatResponseFailure) {
-                return mapChatFetcherErrorToNoNextEditReason(chatResponseFailure);
+            if (cursorLineDiverged) {
+                return new statelessNextEditProvider_1.NoNextEditReason.GotCancelled('cursorLineDiverged');
+            }
+            {
+                const fetchFailure = getFetchFailure();
+                if (fetchFailure) {
+                    return fetchFailure;
+                }
             }
             return new statelessNextEditProvider_1.NoNextEditReason.NoSuggestions(request.documentBeforeEdits, editWindow);
         }
@@ -722,9 +818,11 @@ let XtabProvider = class XtabProvider {
             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 +830,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 +840,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 +872,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 +880,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 +895,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 +908,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 +921,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 +973,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 +1291,4 @@ 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 };
-    }
-    // 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();
-        }
-    })();
-    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 */);
-            }
-        }
-    }
-    return undefined;
-}
 //# sourceMappingURL=xtabProvider.js.map