@vscode/chat-lib 0.0.3 → 0.0.5-0

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

@@ -47,13 +47,17 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
 };
 var XtabProvider_1;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.XtabProvider = exports.IGNORE_TEXT_BEFORE = void 0;
+exports.XtabProvider = void 0;
+exports.findMergeConflictMarkersRange = findMergeConflictMarkersRange;
+const copilot_api_1 = require("@vscode/copilot-api");
 const prompt_tsx_1 = require("@vscode/prompt-tsx");
+const rawTypes_1 = require("@vscode/prompt-tsx/dist/base/output/rawTypes");
 const chatMLFetcher_1 = require("../../../platform/chat/common/chatMLFetcher");
 const commonTypes_1 = require("../../../platform/chat/common/commonTypes");
 const globalStringUtils_1 = require("../../../platform/chat/common/globalStringUtils");
 const configurationService_1 = require("../../../platform/configuration/common/configurationService");
 const diffService_1 = require("../../../platform/diff/common/diffService");
+const chatEndpoint_1 = require("../../../platform/endpoint/node/chatEndpoint");
 const proxyXtabEndpoint_1 = require("../../../platform/endpoint/node/proxyXtabEndpoint");
 const ignoreService_1 = require("../../../platform/ignore/common/ignoreService");
 const xtabPromptOptions = __importStar(require("../../../platform/inlineEdits/common/dataTypes/xtabPromptOptions"));
@@ -66,12 +70,15 @@ const languageContextService_1 = require("../../../platform/languageServer/commo
 const logService_1 = require("../../../platform/log/common/logService");
 const simulationTestContext_1 = require("../../../platform/simulationTestContext/common/simulationTestContext");
 const nullExperimentationService_1 = require("../../../platform/telemetry/common/nullExperimentationService");
+const telemetry_1 = require("../../../platform/telemetry/common/telemetry");
 const workspaceService_1 = require("../../../platform/workspace/common/workspaceService");
 const async_1 = require("../../../util/common/async");
 const errors = __importStar(require("../../../util/common/errors"));
 const result_1 = require("../../../util/common/result");
+const tokenizer_1 = require("../../../util/common/tokenizer");
 const tracing_1 = require("../../../util/common/tracing");
 const async_2 = require("../../../util/vs/base/common/async");
+const cancellation_1 = require("../../../util/vs/base/common/cancellation");
 const stopwatch_1 = require("../../../util/vs/base/common/stopwatch");
 const lineEdit_1 = require("../../../util/vs/editor/common/core/edits/lineEdit");
 const stringEdit_1 = require("../../../util/vs/editor/common/core/edits/stringEdit");
@@ -86,9 +93,9 @@ const ghNearbyNesProvider_1 = require("../../inlineEdits/common/ghNearbyNesProvi
 const nearbyCursorInlineEditProvider_1 = require("../../inlineEdits/common/nearbyCursorInlineEditProvider");
 const importFiltering_1 = require("../../inlineEdits/node/importFiltering");
 const promptCrafting_1 = require("../common/promptCrafting");
+const xtabCurrentDocument_1 = require("../common/xtabCurrentDocument");
 const xtabEndpoint_1 = require("./xtabEndpoint");
 const xtabUtils_1 = require("./xtabUtils");
-exports.IGNORE_TEXT_BEFORE = /```[^\n]*\n/;
 var ResponseTags;
 (function (ResponseTags) {
     ResponseTags.NO_CHANGE = {
@@ -106,7 +113,8 @@ var ResponseTags;
 let XtabProvider = class XtabProvider {
     static { XtabProvider_1 = this; }
     static { this.ID = configurationService_1.XTabProviderId; }
-    constructor(simulationCtx, instaService, workspaceService, diffService, configService, expService, logService, langCtxService, langDiagService, ignoreService) {
+    static { this.computeTokens = (s) => Math.floor(s.length / 4); }
+    constructor(simulationCtx, instaService, workspaceService, diffService, configService, expService, logService, langCtxService, langDiagService, ignoreService, telemetryService) {
         this.simulationCtx = simulationCtx;
         this.instaService = instaService;
         this.workspaceService = workspaceService;
@@ -117,6 +125,7 @@ let XtabProvider = class XtabProvider {
         this.langCtxService = langCtxService;
         this.langDiagService = langDiagService;
         this.ignoreService = ignoreService;
+        this.telemetryService = telemetryService;
         this.ID = XtabProvider_1.ID;
         this.dependsOnSelection = true;
         this.showNextEditPreference = "always" /* ShowNextEditPreference.Always */;
@@ -153,6 +162,9 @@ let XtabProvider = class XtabProvider {
         if (!this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.InlineEditsAllowWhitespaceOnlyChanges, this.expService)) {
             filters.push((edits) => statelessNextEditProviders_1.IgnoreWhitespaceOnlyChanges.filterEdit(activeDoc, edits));
         }
+        if (this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.Internal.InlineEditsUndoInsertionFilteringEnabled, this.expService)) {
+            filters.push((edits) => (0, ghNearbyNesProvider_1.editWouldDeleteWhatWasJustInserted)(activeDoc, new lineEdit_1.LineEdit(edits)) ? [] : edits);
+        }
         return filters.reduce((acc, filter) => filter(acc), edits);
     }
     async _provideNextEdit(request, pushEdit, logContext, cancellationToken) {
@@ -180,99 +192,132 @@ let XtabProvider = class XtabProvider {
         }
     }
     async doGetNextEdit(request, pushEdit, delaySession, logContext, cancellationToken, telemetryBuilder, retryState) {
-        const tracer = this.tracer.sub('doGetNextEdit');
+        return this.doGetNextEditWithSelection(request, (0, nearbyCursorInlineEditProvider_1.getOrDeduceSelectionFromLastEdit)(request.getActiveDocument()), pushEdit, delaySession, logContext, cancellationToken, telemetryBuilder, retryState);
+    }
+    async doGetNextEditWithSelection(request, selection, pushEdit, delaySession, logContext, cancellationToken, telemetryBuilder, retryState) {
+        const tracer = this.tracer.sub('doGetNextEditWithSelection');
         const activeDocument = request.getActiveDocument();
-        const selection = (0, nearbyCursorInlineEditProvider_1.getOrDeduceSelectionFromLastEdit)(activeDocument);
         if (selection === null) {
             return result_1.Result.error(new statelessNextEditProvider_1.NoNextEditReason.Uncategorized(new Error('NoSelection')));
         }
-        const endpoint = this.getEndpoint();
+        const promptOptions = this.determineModelConfiguration(activeDocument);
+        const endpoint = this.getEndpoint(promptOptions.modelName);
         logContext.setEndpointInfo(typeof endpoint.urlOrRequestMetadata === 'string' ? endpoint.urlOrRequestMetadata : JSON.stringify(endpoint.urlOrRequestMetadata.type), endpoint.model);
         telemetryBuilder.setModelName(endpoint.model);
-        const computeTokens = (s) => Math.floor(s.length / 4);
         const cursorPosition = new position_1.Position(selection.endLineNumber, selection.endColumn);
-        const cursorOffset = activeDocument.documentAfterEdits.getTransformer().getOffset(cursorPosition);
-        const currentFileContent = activeDocument.documentAfterEdits;
-        const currentFileContentLines = currentFileContent.getLines();
-        const cursorLineIdx = cursorPosition.lineNumber - 1 /* to convert to 0-based */;
-        const cursorLine = currentFileContentLines[cursorLineIdx];
+        const currentDocument = new xtabCurrentDocument_1.CurrentDocument(activeDocument.documentAfterEdits, cursorPosition);
+        const cursorLine = currentDocument.lines[currentDocument.cursorLineOffset];
         const isCursorAtEndOfLine = cursorPosition.column === cursorLine.trimEnd().length;
         if (isCursorAtEndOfLine) {
             delaySession.setExtraDebounce(this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.Internal.InlineEditsExtraDebounceEndOfLine, this.expService));
         }
         telemetryBuilder.setIsCursorAtLineEnd(isCursorAtEndOfLine);
-        const areaAroundEditWindowLinesRange = this.computeAreaAroundEditWindowLinesRange(currentFileContentLines, cursorLineIdx);
-        const editWindowLinesRange = this.computeEditWindowLinesRange(currentFileContentLines, cursorLineIdx, request, retryState);
-        const cursorOriginalLinesOffset = Math.max(0, cursorLineIdx - editWindowLinesRange.start);
-        const editWindowLastLineLength = activeDocument.documentAfterEdits.getTransformer().getLineLength(editWindowLinesRange.endExclusive);
-        const editWindow = activeDocument.documentAfterEdits.getTransformer().getOffsetRange(new range_1.Range(editWindowLinesRange.start + 1, 1, editWindowLinesRange.endExclusive, editWindowLastLineLength + 1));
-        const editWindowLines = currentFileContentLines.slice(editWindowLinesRange.start, editWindowLinesRange.endExclusive);
+        const areaAroundEditWindowLinesRange = this.computeAreaAroundEditWindowLinesRange(currentDocument);
+        const editWindowLinesRange = this.computeEditWindowLinesRange(currentDocument, request, retryState);
+        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));
+        const editWindowLines = currentDocument.lines.slice(editWindowLinesRange.start, editWindowLinesRange.endExclusive);
         // Expected: editWindow.substring(activeDocument.documentAfterEdits.value) === editWindowLines.join('\n')
-        const doesIncludeCursorTag = editWindowLines.some(line => line.includes(promptCrafting_1.CURSOR_TAG));
+        const doesIncludeCursorTag = editWindowLines.some(line => line.includes(promptCrafting_1.PromptTags.CURSOR));
         const shouldRemoveCursorTagFromResponse = !doesIncludeCursorTag; // we'd like to remove the tag only if the original edit-window didn't include the tag
-        const addCursorTagEdit = stringEdit_1.StringEdit.single(stringEdit_1.StringReplacement.insert(cursorOffset, promptCrafting_1.CURSOR_TAG));
-        const contentWithCursor = addCursorTagEdit.applyOnText(currentFileContent);
-        const contentWithCursorLines = contentWithCursor.getLines();
-        const editWindowWithCursorLines = contentWithCursorLines.slice(editWindowLinesRange.start, editWindowLinesRange.endExclusive);
-        const areaAroundCodeToEdit = [
-            promptCrafting_1.AREA_AROUND_START_TAG,
-            ...contentWithCursorLines.slice(areaAroundEditWindowLinesRange.start, editWindowLinesRange.start),
-            promptCrafting_1.CODE_TO_EDIT_START_TAG,
-            ...editWindowWithCursorLines,
-            promptCrafting_1.CODE_TO_EDIT_END_TAG,
-            ...contentWithCursorLines.slice(editWindowLinesRange.endExclusive, areaAroundEditWindowLinesRange.endExclusive),
-            promptCrafting_1.AREA_AROUND_END_TAG
-        ].join('\n');
-        const promptOptions = this.determinePromptOptions(activeDocument);
-        const areaAroundCodeToEditForCurrentFile = promptOptions.currentFile.includeTags
-            ? areaAroundCodeToEdit
-            : [
-                ...contentWithCursorLines.slice(areaAroundEditWindowLinesRange.start, editWindowLinesRange.start),
-                ...editWindowLines,
-                ...contentWithCursorLines.slice(editWindowLinesRange.endExclusive, areaAroundEditWindowLinesRange.endExclusive),
-            ].join('\n');
-        const { taggedCurrentFileContent, nLines: nLinesCurrentFile } = (0, promptCrafting_1.createTaggedCurrentFileContentUsingPagedClipping)(currentFileContentLines, areaAroundCodeToEditForCurrentFile, areaAroundEditWindowLinesRange, computeTokens, promptOptions.pagedClipping.pageSize, promptOptions.currentFile);
+        const taggedCurrentFileContentResult = this.constructTaggedFile(currentDocument, editWindowLinesRange, areaAroundEditWindowLinesRange, promptOptions, XtabProvider_1.computeTokens, { includeLineNumbers: false });
+        if (taggedCurrentFileContentResult.isError()) {
+            return result_1.Result.error(new statelessNextEditProvider_1.NoNextEditReason.PromptTooLarge('currentFile'));
+        }
+        const { taggedCurrentFileR: { taggedCurrentFileContent, nLines: nLinesCurrentFile }, areaAroundCodeToEdit } = taggedCurrentFileContentResult.val;
         telemetryBuilder.setNLinesOfCurrentFileInPrompt(nLinesCurrentFile);
-        const recordingEnabled = this.configService.getConfig(configurationService_1.ConfigKey.Internal.InlineEditsLogContextRecorderEnabled);
-        let langCtx;
-        if (promptOptions.languageContext.enabled || recordingEnabled) {
-            const langCtxPromise = this.getLanguageContext(request, delaySession, activeDocument, cursorPosition, logContext, cancellationToken);
-            if (promptOptions.languageContext.enabled) {
-                langCtx = await langCtxPromise;
-            }
-            if (recordingEnabled) {
-                logContext.setFileDiagnostics(this.langDiagService.getAllDiagnostics());
-                langCtxPromise.then(langCtxs => {
-                    if (langCtxs) {
-                        logContext.setLanguageContext(langCtxs);
-                    }
-                });
-            }
+        const langCtx = await this.getAndProcessLanguageContext(request, delaySession, activeDocument, cursorPosition, promptOptions, logContext, cancellationToken);
+        if (cancellationToken.isCancellationRequested) {
+            return result_1.Result.error(new statelessNextEditProvider_1.NoNextEditReason.GotCancelled('afterLanguageContextAwait'));
         }
-        const userPrompt = (0, promptCrafting_1.getUserPrompt)(request, taggedCurrentFileContent, areaAroundCodeToEdit, langCtx, computeTokens, promptOptions);
+        const promptPieces = new promptCrafting_1.PromptPieces(currentDocument, editWindowLinesRange, areaAroundEditWindowLinesRange, activeDocument, request.xtabEditHistory, taggedCurrentFileContent, areaAroundCodeToEdit, langCtx, XtabProvider_1.computeTokens, promptOptions);
+        const userPrompt = (0, promptCrafting_1.getUserPrompt)(promptPieces);
         const prediction = this.getPredictedOutput(editWindowLines, promptOptions.promptingStrategy);
-        const messages = [
-            {
-                role: prompt_tsx_1.Raw.ChatRole.System,
-                content: (0, globalStringUtils_1.toTextParts)(this.pickSystemPrompt(promptOptions.promptingStrategy))
-            },
-            { role: prompt_tsx_1.Raw.ChatRole.User, content: (0, globalStringUtils_1.toTextParts)(userPrompt) }
-        ];
+        const messages = constructMessages({
+            systemMsg: this.pickSystemPrompt(promptOptions.promptingStrategy),
+            userMsg: userPrompt,
+        });
         logContext.setPrompt(messages);
         telemetryBuilder.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 = charCount(messages);
+        if (promptCharCount > HARD_CHAR_LIMIT) {
+            return result_1.Result.error(new statelessNextEditProvider_1.NoNextEditReason.PromptTooLarge('final'));
+        }
         await this.debounce(delaySession, telemetryBuilder);
         if (cancellationToken.isCancellationRequested) {
             return result_1.Result.error(new statelessNextEditProvider_1.NoNextEditReason.GotCancelled('afterDebounce'));
         }
         request.fetchIssued = true;
         const cursorLineOffset = cursorPosition.column;
-        this.streamEdits(request, pushEdit, endpoint, messages, editWindow, editWindowLines, cursorOriginalLinesOffset, cursorLineOffset, editWindowLinesRange, prediction, {
+        this.streamEdits(request, pushEdit, endpoint, messages, editWindow, editWindowLines, cursorOriginalLinesOffset, cursorLineOffset, editWindowLinesRange, promptPieces, prediction, {
             shouldRemoveCursorTagFromResponse,
             promptingStrategy: promptOptions.promptingStrategy,
             retryState,
         }, delaySession, tracer, telemetryBuilder, logContext, cancellationToken);
         return result_1.Result.ok(undefined);
     }
+    constructTaggedFile(currentDocument, editWindowLinesRange, areaAroundEditWindowLinesRange, promptOptions, computeTokens, opts) {
+        const contentWithCursorAsLinesOriginal = (() => {
+            const addCursorTagEdit = stringEdit_1.StringEdit.single(stringEdit_1.StringReplacement.insert(currentDocument.cursorOffset, promptCrafting_1.PromptTags.CURSOR));
+            const contentWithCursor = addCursorTagEdit.applyOnText(currentDocument.content);
+            return contentWithCursor.getLines();
+        })();
+        const addLineNumbers = (lines) => lines.map((line, idx) => `${idx}| ${line}`);
+        const contentWithCursorAsLines = opts.includeLineNumbers
+            ? addLineNumbers(contentWithCursorAsLinesOriginal)
+            : contentWithCursorAsLinesOriginal;
+        const editWindowWithCursorAsLines = contentWithCursorAsLines.slice(editWindowLinesRange.start, editWindowLinesRange.endExclusive);
+        const areaAroundCodeToEdit = [
+            promptCrafting_1.PromptTags.AREA_AROUND.start,
+            ...contentWithCursorAsLines.slice(areaAroundEditWindowLinesRange.start, editWindowLinesRange.start),
+            promptCrafting_1.PromptTags.EDIT_WINDOW.start,
+            ...editWindowWithCursorAsLines,
+            promptCrafting_1.PromptTags.EDIT_WINDOW.end,
+            ...contentWithCursorAsLines.slice(editWindowLinesRange.endExclusive, areaAroundEditWindowLinesRange.endExclusive),
+            promptCrafting_1.PromptTags.AREA_AROUND.end
+        ].join('\n');
+        const currentFileContentLines = opts.includeLineNumbers
+            ? addLineNumbers(currentDocument.lines)
+            : currentDocument.lines;
+        let areaAroundCodeToEditForCurrentFile;
+        if (promptOptions.currentFile.includeTags) {
+            areaAroundCodeToEditForCurrentFile = areaAroundCodeToEdit;
+        }
+        else {
+            const editWindowLines = currentFileContentLines.slice(editWindowLinesRange.start, editWindowLinesRange.endExclusive);
+            areaAroundCodeToEditForCurrentFile = [
+                ...contentWithCursorAsLines.slice(areaAroundEditWindowLinesRange.start, editWindowLinesRange.start),
+                ...editWindowLines,
+                ...contentWithCursorAsLines.slice(editWindowLinesRange.endExclusive, areaAroundEditWindowLinesRange.endExclusive),
+            ].join('\n');
+        }
+        const taggedCurrentFileContentResult = (0, promptCrafting_1.createTaggedCurrentFileContentUsingPagedClipping)(currentFileContentLines, areaAroundCodeToEditForCurrentFile, areaAroundEditWindowLinesRange, computeTokens, promptOptions.pagedClipping.pageSize, promptOptions.currentFile);
+        return taggedCurrentFileContentResult.map(taggedCurrentFileR => ({
+            taggedCurrentFileR,
+            areaAroundCodeToEdit,
+        }));
+    }
+    getAndProcessLanguageContext(request, delaySession, activeDocument, cursorPosition, promptOptions, logContext, cancellationToken) {
+        const recordingEnabled = this.configService.getConfig(configurationService_1.ConfigKey.Internal.InlineEditsLogContextRecorderEnabled);
+        if (!promptOptions.languageContext.enabled && !recordingEnabled) {
+            return Promise.resolve(undefined);
+        }
+        const langCtxPromise = this.getLanguageContext(request, delaySession, activeDocument, cursorPosition, logContext, 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) {
+            logContext.setFileDiagnostics(this.langDiagService.getAllDiagnostics());
+            langCtxPromise.then(langCtxs => {
+                if (langCtxs) {
+                    logContext.setLanguageContext(langCtxs);
+                }
+            });
+        }
+        return promptOptions.languageContext.enabled
+            ? langCtxPromise
+            : Promise.resolve(undefined);
+    }
     async getLanguageContext(request, delaySession, activeDocument, cursorPosition, logContext, cancellationToken) {
         try {
             const textDoc = this.workspaceService.textDocuments.find(doc => doc.uri.toString() === activeDocument.id.uri);
@@ -335,8 +380,9 @@ let XtabProvider = class XtabProvider {
         }
     }
     async streamEdits(request, pushEdit, endpoint, messages, editWindow, editWindowLines, cursorOriginalLinesOffset, cursorLineOffset, // cursor offset within the line it's in; 1-based
-    editWindowLineRange, prediction, opts, delaySession, parentTracer, telemetryBuilder, logContext, cancellationToken) {
+    editWindowLineRange, promptPieces, prediction, opts, delaySession, parentTracer, telemetryBuilder, logContext, cancellationToken) {
         const tracer = parentTracer.sub('streamEdits');
+        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 = '';
@@ -346,26 +392,35 @@ let XtabProvider = class XtabProvider {
         telemetryBuilder.setFetchStartedAt();
         logContext.setFetchStartTime();
         // we must not await this promise because we want to stream edits as they come in
-        const fetchResultPromise = endpoint.makeChatRequest(XtabProvider_1.ID, messages, async (text, _, delta) => {
-            if (!firstTokenReceived.isSettled) {
-                firstTokenReceived.complete();
-            }
-            if (ttft === undefined) {
-                ttft = fetchRequestStopWatch.elapsed();
-                logContext.addLog(`TTFT ${ttft} ms`);
-            }
-            fetchStreamSource.update(text, delta);
-            responseSoFar = text;
-            logContext.setResponse(responseSoFar);
-            return undefined;
-        }, cancellationToken, commonTypes_1.ChatLocation.Other, undefined, {
-            temperature: 0,
-            // max_tokens: 256, // `max_tokens` is not supported along with `prediction` - https://platform.openai.com/docs/guides/predicted-outputs#limitations
-            stream: true,
-            prediction,
-        }, undefined, {
-            requestId: request.id,
-        });
+        const fetchResultPromise = endpoint.makeChatRequest2({
+            debugName: XtabProvider_1.ID,
+            messages,
+            finishedCb: async (text, _, delta) => {
+                if (!firstTokenReceived.isSettled) {
+                    firstTokenReceived.complete();
+                }
+                if (ttft === undefined) {
+                    ttft = fetchRequestStopWatch.elapsed();
+                    logContext.addLog(`TTFT ${ttft} ms`);
+                }
+                fetchStreamSource.update(text, delta);
+                responseSoFar = text;
+                logContext.setResponse(responseSoFar);
+                return undefined;
+            },
+            location: commonTypes_1.ChatLocation.Other,
+            source: undefined,
+            requestOptions: {
+                temperature: 0,
+                stream: true,
+                prediction,
+            },
+            userInitiatedRequest: undefined,
+            telemetryProperties: {
+                requestId: request.id,
+            },
+            useFetcher,
+        }, cancellationToken);
         telemetryBuilder.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]);
@@ -409,7 +464,7 @@ let XtabProvider = class XtabProvider {
                 logContext.addLog(trace);
                 tracer.trace(trace);
                 return opts.shouldRemoveCursorTagFromResponse
-                    ? v.replaceAll(promptCrafting_1.CURSOR_TAG, '')
+                    ? v.replaceAll(promptCrafting_1.PromptTags.CURSOR, '')
                     : v;
             });
         })();
@@ -432,7 +487,7 @@ let XtabProvider = class XtabProvider {
             }
             const trimmedLines = firstLine.value.trim();
             if (trimmedLines === ResponseTags.NO_CHANGE.start) {
-                this.pushNoSuggestionsOrRetry(request, editWindow, pushEdit, delaySession, logContext, cancellationToken, telemetryBuilder, opts.retryState);
+                await this.pushNoSuggestionsOrRetry(request, editWindow, promptPieces, pushEdit, delaySession, logContext, cancellationToken, telemetryBuilder, opts.retryState);
                 return;
             }
             if (trimmedLines === ResponseTags.INSERT.start) {
@@ -518,12 +573,6 @@ let XtabProvider = class XtabProvider {
                     }
                     logContext.setResponse(responseSoFar);
                     for (const singleLineEdit of singleLineEdits) {
-                        const lineEdit = new lineEdit_1.LineEdit([singleLineEdit]);
-                        if ((0, ghNearbyNesProvider_1.editWouldDeleteWhatWasJustInserted)(request.getActiveDocument(), lineEdit)) {
-                            this.trace(`filtering edit because it would undo previous insertion: ${singleLineEdit.toString()}`, logContext, tracer);
-                            i++;
-                            continue;
-                        }
                         this.trace(`pushing edit #${i}:\n${singleLineEdit.toString()}`, logContext, tracer);
                         if (!hasBeenDelayed) { // delay only the first one
                             hasBeenDelayed = true;
@@ -542,7 +591,7 @@ let XtabProvider = class XtabProvider {
                     pushEdit(result_1.Result.error(new statelessNextEditProvider_1.NoNextEditReason.NoSuggestions(request.documentBeforeEdits, editWindow)));
                 }
                 else {
-                    this.pushNoSuggestionsOrRetry(request, editWindow, pushEdit, delaySession, logContext, cancellationToken, telemetryBuilder, opts.retryState);
+                    await this.pushNoSuggestionsOrRetry(request, editWindow, promptPieces, pushEdit, delaySession, logContext, cancellationToken, telemetryBuilder, opts.retryState);
                 }
             }
             catch (err) {
@@ -552,29 +601,58 @@ let XtabProvider = class XtabProvider {
             }
         })();
     }
-    pushNoSuggestionsOrRetry(request, editWindow, pushEdit, delaySession, logContext, cancellationToken, telemetryBuilder, retryState) {
+    async pushNoSuggestionsOrRetry(request, editWindow, promptPieces, pushEdit, delaySession, logContext, cancellationToken, telemetryBuilder, retryState) {
         const allowRetryWithExpandedWindow = this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.Internal.InlineEditsXtabProviderRetryWithNMoreLinesBelow, this.expService);
         // if allowed to retry and not retrying already, flip the retry state and try again
         if (allowRetryWithExpandedWindow && retryState === 0 /* RetryState.NotRetrying */ && request.expandedEditWindowNLines === undefined) {
-            this.doGetNextEdit(request, pushEdit, delaySession, logContext, cancellationToken, telemetryBuilder, 1 /* RetryState.RetryingWithExpandedWindow */);
+            this.doGetNextEdit(request, pushEdit, delaySession, logContext, cancellationToken, telemetryBuilder, 1 /* RetryState.Retrying */);
             return;
         }
+        const nextCursorLinePredictionEnabled = this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.Internal.InlineEditsNextCursorPredictionEnabled, this.expService);
+        if (nextCursorLinePredictionEnabled && retryState === 0 /* RetryState.NotRetrying */) {
+            const nextCursorLineR = await this.predictNextCursorPosition(promptPieces);
+            if (nextCursorLineR.isError()) {
+                this.tracer.trace(`Predicted next cursor line error: ${nextCursorLineR.err.message}`);
+                telemetryBuilder.setNextCursorLineError(nextCursorLineR.err.message);
+            }
+            else {
+                const nextCursorLine = nextCursorLineR.val;
+                const lineDistanceFromCursorLine = nextCursorLine - promptPieces.currentDocument.cursorLineOffset;
+                telemetryBuilder.setNextCursorLineDistance(lineDistanceFromCursorLine);
+                this.tracer.trace(`Predicted next cursor line: ${nextCursorLine}`);
+                if (nextCursorLine >= promptPieces.currentDocument.lines.length) { // >= because the line index is zero-based
+                    this.tracer.trace(`Predicted next cursor line error: exceedsDocumentLines`);
+                    telemetryBuilder.setNextCursorLineError('exceedsDocumentLines');
+                }
+                else if (promptPieces.editWindowLinesRange.contains(nextCursorLine)) {
+                    this.tracer.trace(`Predicted next cursor line error: withinEditWindow`);
+                    telemetryBuilder.setNextCursorLineError('withinEditWindow');
+                }
+                else {
+                    this.doGetNextEditWithSelection(request, new range_1.Range(nextCursorLine + 1, 1, nextCursorLine + 1, 1), pushEdit, delaySession, logContext, cancellationToken, telemetryBuilder, 1 /* RetryState.Retrying */);
+                    return;
+                }
+            }
+        }
         pushEdit(result_1.Result.error(new statelessNextEditProvider_1.NoNextEditReason.NoSuggestions(request.documentBeforeEdits, editWindow)));
         return;
     }
-    computeAreaAroundEditWindowLinesRange(currentDocLines, cursorLine) {
+    computeAreaAroundEditWindowLinesRange(currentDocument) {
+        const cursorLine = currentDocument.cursorLineOffset;
         const areaAroundStart = Math.max(0, cursorLine - promptCrafting_1.N_LINES_AS_CONTEXT);
-        const areaAroundEndExcl = Math.min(currentDocLines.length, cursorLine + promptCrafting_1.N_LINES_AS_CONTEXT + 1);
+        const areaAroundEndExcl = Math.min(currentDocument.lines.length, cursorLine + promptCrafting_1.N_LINES_AS_CONTEXT + 1);
         return new offsetRange_1.OffsetRange(areaAroundStart, areaAroundEndExcl);
     }
-    computeEditWindowLinesRange(currentDocLines, cursorLine, request, retryState) {
+    computeEditWindowLinesRange(currentDocument, request, retryState) {
+        const currentDocLines = currentDocument.lines;
+        const cursorLineOffset = currentDocument.cursorLineOffset;
         let nLinesAbove;
         {
             const useVaryingLinesAbove = this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.Internal.InlineEditsXtabProviderUseVaryingLinesAbove, this.expService);
             if (useVaryingLinesAbove) {
                 nLinesAbove = 0; // default
                 for (let i = 0; i < 8; ++i) {
-                    const lineIdx = cursorLine - i;
+                    const lineIdx = cursorLineOffset - i;
                     if (lineIdx < 0) {
                         break;
                     }
@@ -605,18 +683,30 @@ let XtabProvider = class XtabProvider {
                 nLinesBelow = promptCrafting_1.N_LINES_BELOW; // default
             }
         }
-        if (retryState === 1 /* RetryState.RetryingWithExpandedWindow */) {
+        if (retryState === 1 /* RetryState.Retrying */) {
             nLinesBelow += this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.Internal.InlineEditsXtabProviderRetryWithNMoreLinesBelow, this.expService) ?? 0;
         }
-        const codeToEditStart = Math.max(0, cursorLine - nLinesAbove);
-        const codeToEditEndExcl = Math.min(currentDocLines.length, cursorLine + nLinesBelow + 1);
+        let codeToEditStart = Math.max(0, cursorLineOffset - nLinesAbove);
+        let codeToEditEndExcl = Math.min(currentDocLines.length, cursorLineOffset + nLinesBelow + 1);
+        const maxMergeConflictLines = this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.Internal.InlineEditsXtabMaxMergeConflictLines, this.expService);
+        if (maxMergeConflictLines) {
+            const tentativeEditWindow = new offsetRange_1.OffsetRange(codeToEditStart, codeToEditEndExcl);
+            const mergeConflictRange = findMergeConflictMarkersRange(currentDocLines, tentativeEditWindow, maxMergeConflictLines);
+            if (mergeConflictRange) {
+                const onlyMergeConflictLines = this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.Internal.InlineEditsXtabOnlyMergeConflictLines, this.expService);
+                if (onlyMergeConflictLines) {
+                    this.tracer.trace(`Expanding edit window to include ONLY merge conflict markers: ${mergeConflictRange.toString()}`);
+                    codeToEditStart = mergeConflictRange.start;
+                    codeToEditEndExcl = mergeConflictRange.endExclusive;
+                }
+                else {
+                    this.tracer.trace(`Expanding edit window to include merge conflict markers: ${mergeConflictRange.toString()}; edit window range [${codeToEditStart}, ${codeToEditEndExcl})`);
+                    codeToEditEndExcl = Math.max(codeToEditEndExcl, mergeConflictRange.endExclusive);
+                }
+            }
+        }
         return new offsetRange_1.OffsetRange(codeToEditStart, codeToEditEndExcl);
     }
-    static getBacktickSection(text) {
-        const textTrimmedStart = text.replace(/^\`\`\`[a-zA-Z]*\r?\n/, '');
-        const textTrimmedEnd = textTrimmedStart.replace(/(\r?\n)\`\`\`$/, '');
-        return textTrimmedEnd;
-    }
     static mapChatFetcherErrorToNoNextEditReason(fetchError) {
         switch (fetchError.type) {
             case commonTypes_1.ChatFetchResponseType.Canceled:
@@ -640,48 +730,182 @@ let XtabProvider = class XtabProvider {
                 return new statelessNextEditProvider_1.NoNextEditReason.FetchFailure(errors.fromUnknown(fetchError));
         }
     }
-    determinePromptOptions(activeDocument) {
+    determineModelConfiguration(activeDocument) {
         if (this.forceUseDefaultModel) {
-            return xtabPromptOptions.DEFAULT_OPTIONS;
-        }
-        else {
-            const promptingStrategy = this.determinePromptingStrategy({
-                isXtabUnifiedModel: this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.Internal.InlineEditsXtabUseUnifiedModel, this.expService),
-                isCodexV21NesUnified: this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.Internal.InlineEditsXtabCodexV21NesUnified, this.expService),
-                useSimplifiedPrompt: this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.Internal.InlineEditsXtabProviderUseSimplifiedPrompt, this.expService),
-                useXtab275Prompting: this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.Internal.InlineEditsXtabProviderUseXtab275Prompting, this.expService),
-                useNes41Miniv3Prompting: this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.Internal.InlineEditsXtabUseNes41Miniv3Prompting, this.expService),
-            });
             return {
-                promptingStrategy,
-                currentFile: {
-                    maxTokens: this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.Internal.InlineEditsXtabCurrentFileMaxTokens, this.expService),
-                    includeTags: promptingStrategy !== xtabPromptOptions.PromptingStrategy.UnifiedModel /* unified model doesn't use tags in current file */ && this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.Internal.InlineEditsXtabIncludeTagsInCurrentFile, this.expService),
-                    prioritizeAboveCursor: this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.Internal.InlineEditsXtabPrioritizeAboveCursor, this.expService)
-                },
-                pagedClipping: {
-                    pageSize: this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.Internal.InlineEditsXtabPageSize, this.expService)
-                },
-                recentlyViewedDocuments: {
-                    nDocuments: this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.Internal.InlineEditsXtabNRecentlyViewedDocuments, this.expService),
-                    maxTokens: this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.Internal.InlineEditsXtabRecentlyViewedDocumentsMaxTokens, this.expService),
-                    includeViewedFiles: this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.Internal.InlineEditsXtabIncludeViewedFiles, this.expService),
-                },
-                languageContext: this.determineLanguageContextOptions(activeDocument.languageId, {
-                    enabled: this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.Internal.InlineEditsXtabLanguageContextEnabled, this.expService),
-                    enabledLanguages: this.configService.getConfig(configurationService_1.ConfigKey.Internal.InlineEditsXtabLanguageContextEnabledLanguages),
-                    maxTokens: this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.Internal.InlineEditsXtabLanguageContextMaxTokens, this.expService),
-                }),
-                diffHistory: {
-                    nEntries: this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.Internal.InlineEditsXtabDiffNEntries, this.expService),
-                    maxTokens: this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.Internal.InlineEditsXtabDiffMaxTokens, this.expService),
-                    onlyForDocsInPrompt: this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.Internal.InlineEditsXtabDiffOnlyForDocsInPrompt, this.expService),
-                    useRelativePaths: this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.Internal.InlineEditsXtabDiffUseRelativePaths, this.expService),
-                }
+                modelName: undefined,
+                ...xtabPromptOptions.DEFAULT_OPTIONS,
             };
         }
+        const promptingStrategy = this.determinePromptingStrategy();
+        const sourcedModelConfig = {
+            modelName: this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.Internal.InlineEditsXtabProviderModelName, this.expService),
+            promptingStrategy,
+            currentFile: {
+                maxTokens: this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.Internal.InlineEditsXtabCurrentFileMaxTokens, this.expService),
+                includeTags: promptingStrategy !== xtabPromptOptions.PromptingStrategy.UnifiedModel /* unified model doesn't use tags in current file */ && this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.Internal.InlineEditsXtabIncludeTagsInCurrentFile, this.expService),
+                prioritizeAboveCursor: this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.Internal.InlineEditsXtabPrioritizeAboveCursor, this.expService)
+            },
+            pagedClipping: {
+                pageSize: this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.Internal.InlineEditsXtabPageSize, this.expService)
+            },
+            recentlyViewedDocuments: {
+                nDocuments: this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.Internal.InlineEditsXtabNRecentlyViewedDocuments, this.expService),
+                maxTokens: this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.Internal.InlineEditsXtabRecentlyViewedDocumentsMaxTokens, this.expService),
+                includeViewedFiles: this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.Internal.InlineEditsXtabIncludeViewedFiles, this.expService),
+            },
+            languageContext: this.determineLanguageContextOptions(activeDocument.languageId, {
+                enabled: this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.Internal.InlineEditsXtabLanguageContextEnabled, this.expService),
+                enabledLanguages: this.configService.getConfig(configurationService_1.ConfigKey.Internal.InlineEditsXtabLanguageContextEnabledLanguages),
+                maxTokens: this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.Internal.InlineEditsXtabLanguageContextMaxTokens, this.expService),
+            }),
+            diffHistory: {
+                nEntries: this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.Internal.InlineEditsXtabDiffNEntries, this.expService),
+                maxTokens: this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.Internal.InlineEditsXtabDiffMaxTokens, this.expService),
+                onlyForDocsInPrompt: this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.Internal.InlineEditsXtabDiffOnlyForDocsInPrompt, this.expService),
+                useRelativePaths: this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.Internal.InlineEditsXtabDiffUseRelativePaths, this.expService),
+            },
+            includePostScript: true,
+        };
+        const localOverridingModelConfig = this.configService.getConfig(configurationService_1.ConfigKey.Internal.InlineEditsXtabProviderModelConfiguration);
+        if (localOverridingModelConfig) {
+            return XtabProvider_1.overrideModelConfig(sourcedModelConfig, localOverridingModelConfig);
+        }
+        const expBasedModelConfig = this.overrideByStringModelConfig(sourcedModelConfig, configurationService_1.ConfigKey.Internal.InlineEditsXtabProviderModelConfigurationString);
+        if (expBasedModelConfig) {
+            return expBasedModelConfig;
+        }
+        const defaultModelConfig = this.overrideByStringModelConfig(sourcedModelConfig, configurationService_1.ConfigKey.Internal.InlineEditsXtabProviderDefaultModelConfigurationString);
+        if (defaultModelConfig) {
+            return defaultModelConfig;
+        }
+        return sourcedModelConfig;
     }
-    determinePromptingStrategy({ isXtabUnifiedModel, isCodexV21NesUnified, useSimplifiedPrompt, useXtab275Prompting, useNes41Miniv3Prompting }) {
+    overrideByStringModelConfig(originalModelConfig, configKey) {
+        const configString = this.configService.getExperimentBasedConfig(configKey, this.expService);
+        if (configString === undefined) {
+            return undefined;
+        }
+        let parsedConfig;
+        try {
+            parsedConfig = JSON.parse(configString);
+        }
+        catch (e) {
+            /* __GDPR__
+                "incorrectNesModelConfig" : {
+                    "owner": "ulugbekna",
+                    "comment": "Capture if model configuration string is invalid JSON.",
+                    "configName": { "classification": "SystemMetaData", "purpose": "FeatureInsight", "comment": "Name of the configuration that failed to parse." },
+                    "errorMessage": { "classification": "SystemMetaData", "purpose": "FeatureInsight", "comment": "Error message from JSON.parse." },
+                    "configValue": { "classification": "SystemMetaData", "purpose": "FeatureInsight", "comment": "The invalid JSON string." }
+                }
+            */
+            this.telemetryService.sendMSFTTelemetryEvent('incorrectNesModelConfig', { configName: configKey.id, errorMessage: errors.toString(errors.fromUnknown(e)), configValue: configString });
+        }
+        if (parsedConfig) {
+            return XtabProvider_1.overrideModelConfig(originalModelConfig, parsedConfig);
+        }
+        return undefined;
+    }
+    static overrideModelConfig(modelConfig, overridingConfig) {
+        return {
+            ...modelConfig,
+            modelName: overridingConfig.modelName,
+            promptingStrategy: overridingConfig.promptingStrategy,
+            currentFile: {
+                ...modelConfig.currentFile,
+                includeTags: overridingConfig.includeTagsInCurrentFile,
+            },
+        };
+    }
+    async predictNextCursorPosition(promptPieces) {
+        const tracer = this.tracer.sub('predictNextCursorPosition');
+        const systemMessage = 'Your task is to predict the next line number in the current file where the developer is most likely to make their next edit, using the provided context.';
+        const currentFileContentR = this.constructTaggedFile(promptPieces.currentDocument, promptPieces.editWindowLinesRange, promptPieces.areaAroundEditWindowLinesRange, {
+            ...promptPieces.opts,
+            currentFile: {
+                ...promptPieces.opts.currentFile,
+                includeTags: false,
+            }
+        }, XtabProvider_1.computeTokens, { includeLineNumbers: true });
+        if (currentFileContentR.isError()) {
+            tracer.trace(`Failed to construct tagged file: ${currentFileContentR.err}`);
+            return result_1.Result.fromString(currentFileContentR.err);
+        }
+        const { taggedCurrentFileR: { taggedCurrentFileContent }, areaAroundCodeToEdit } = currentFileContentR.val;
+        const newPromptPieces = new promptCrafting_1.PromptPieces(promptPieces.currentDocument, promptPieces.editWindowLinesRange, promptPieces.areaAroundEditWindowLinesRange, promptPieces.activeDoc, promptPieces.xtabHistory, taggedCurrentFileContent, areaAroundCodeToEdit, promptPieces.langCtx, XtabProvider_1.computeTokens, {
+            ...promptPieces.opts,
+            includePostScript: false,
+        });
+        const userMessage = (0, promptCrafting_1.getUserPrompt)(newPromptPieces);
+        const messages = constructMessages({
+            systemMsg: systemMessage,
+            userMsg: userMessage
+        });
+        const modelName = this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.Internal.InlineEditsNextCursorPredictionModelName, this.expService);
+        if (modelName === undefined) {
+            tracer.trace('Model name for cursor prediction is not defined; skipping prediction');
+            return result_1.Result.fromString('modelNameNotDefined');
+        }
+        const url = this.configService.getConfig(configurationService_1.ConfigKey.Internal.InlineEditsNextCursorPredictionUrl);
+        const secretKey = this.configService.getConfig(configurationService_1.ConfigKey.Internal.InlineEditsNextCursorPredictionApiKey);
+        const endpoint = this.instaService.createInstance(chatEndpoint_1.ChatEndpoint, {
+            id: modelName,
+            name: 'nes.nextCursorPosition',
+            urlOrRequestMetadata: url ? url : { type: copilot_api_1.RequestType.ProxyChatCompletions },
+            model_picker_enabled: false,
+            is_chat_default: false,
+            is_chat_fallback: false,
+            version: '',
+            capabilities: {
+                type: 'chat',
+                family: '',
+                tokenizer: tokenizer_1.TokenizerType.CL100K,
+                limits: undefined,
+                supports: {
+                    parallel_tool_calls: false,
+                    tool_calls: false,
+                    streaming: true,
+                    vision: false,
+                    prediction: false,
+                    thinking: false
+                }
+            },
+        });
+        const response = await endpoint.makeChatRequest2({
+            messages,
+            debugName: 'nes.nextCursorPosition',
+            finishedCb: undefined,
+            location: commonTypes_1.ChatLocation.Other,
+            requestOptions: secretKey ? {
+                secretKey,
+            } : undefined,
+        }, cancellation_1.CancellationToken.None);
+        if (response.type !== commonTypes_1.ChatFetchResponseType.Success) {
+            return result_1.Result.fromString(`fetchError:${response.type}`);
+        }
+        try {
+            const trimmed = response.value.trim();
+            const lineNumber = parseInt(trimmed, 10);
+            if (isNaN(lineNumber)) {
+                return result_1.Result.fromString(`gotNaN`);
+            }
+            if (lineNumber < 0) {
+                return result_1.Result.fromString(`negativeLineNumber`);
+            }
+            return result_1.Result.ok(lineNumber);
+        }
+        catch (err) {
+            tracer.trace(`Failed to parse predicted line number from response '${response.value}': ${err}`);
+            return result_1.Result.fromString(`failedToParseLine:"${response.value}". Error ${errors.fromUnknown(err).message}`);
+        }
+    }
+    determinePromptingStrategy() {
+        const isXtabUnifiedModel = this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.Internal.InlineEditsXtabUseUnifiedModel, this.expService);
+        const isCodexV21NesUnified = this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.Internal.InlineEditsXtabCodexV21NesUnified, this.expService);
+        const useSimplifiedPrompt = this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.Internal.InlineEditsXtabProviderUseSimplifiedPrompt, this.expService);
+        const useXtab275Prompting = this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.Internal.InlineEditsXtabProviderUseXtab275Prompting, this.expService);
+        const useNes41Miniv3Prompting = this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.Internal.InlineEditsXtabUseNes41Miniv3Prompting, this.expService);
         if (isXtabUnifiedModel) {
             return xtabPromptOptions.PromptingStrategy.UnifiedModel;
         }
@@ -723,18 +947,14 @@ let XtabProvider = class XtabProvider {
         }
         return { enabled, maxTokens };
     }
-    getEndpoint() {
+    getEndpoint(configuredModelName) {
         const url = this.configService.getConfig(configurationService_1.ConfigKey.Internal.InlineEditsXtabProviderUrl);
         const apiKey = this.configService.getConfig(configurationService_1.ConfigKey.Internal.InlineEditsXtabProviderApiKey);
         const hasOverriddenUrlAndApiKey = url !== undefined && apiKey !== undefined;
-        const configuredModelName = this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.Internal.InlineEditsXtabProviderModelName, this.expService);
         if (hasOverriddenUrlAndApiKey) {
             return this.instaService.createInstance(xtabEndpoint_1.XtabEndpoint, url, apiKey, configuredModelName);
         }
-        const modelName = this.forceUseDefaultModel
-            ? undefined
-            : this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.Internal.InlineEditsXtabProviderModelName, this.expService);
-        return (0, proxyXtabEndpoint_1.createProxyXtabEndpoint)(this.instaService, modelName);
+        return (0, proxyXtabEndpoint_1.createProxyXtabEndpoint)(this.instaService, configuredModelName);
     }
     getPredictedOutput(editWindowLines, promptingStrategy) {
         return this.configService.getConfig(configurationService_1.ConfigKey.Internal.InlineEditsXtabProviderUsePrediction)
@@ -793,6 +1013,45 @@ exports.XtabProvider = XtabProvider = XtabProvider_1 = __decorate([
     __param(6, logService_1.ILogService),
     __param(7, languageContextProviderService_1.ILanguageContextProviderService),
     __param(8, languageDiagnosticsService_1.ILanguageDiagnosticsService),
-    __param(9, ignoreService_1.IIgnoreService)
+    __param(9, ignoreService_1.IIgnoreService),
+    __param(10, telemetry_1.ITelemetryService)
 ], XtabProvider);
+/**
+ * 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;
+}
+function constructMessages({ systemMsg, userMsg }) {
+    return [
+        {
+            role: prompt_tsx_1.Raw.ChatRole.System,
+            content: (0, globalStringUtils_1.toTextParts)(systemMsg)
+        },
+        {
+            role: prompt_tsx_1.Raw.ChatRole.User,
+            content: (0, globalStringUtils_1.toTextParts)(userMsg)
+        }
+    ];
+}
+function charCount(messages) {
+    const promptCharCount = messages.reduce((total, msg) => total + msg.content.reduce((subtotal, part) => subtotal + (part.type === rawTypes_1.ChatCompletionContentPartKind.Text ? part.text.length : 0), 0), 0);
+    return promptCharCount;
+}
 //# sourceMappingURL=xtabProvider.js.map