@vscode/chat-lib 0.3.0 → 0.3.1-0

package/dist/src/_internal/extension/completions-core/vscode-node/lib/src/ghostText/ghostText.js

@@ -1,27 +1,29 @@
 "use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ForceMultiLine = exports.ResultType = void 0;
+exports.ForceMultiLine = exports.GhostTextComputer = void 0;
 exports.getGhostText = getGhostText;
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
+const logService_1 = require("../../../../../../platform/log/common/logService");
 const telemetry_1 = require("../../../../../../platform/telemetry/common/telemetry");
 const crypto_1 = require("../../../../../../util/common/crypto");
 const uuid_1 = require("../../../../../../util/vs/base/common/uuid");
 const instantiation_1 = require("../../../../../../util/vs/platform/instantiation/common/instantiation");
-const parse_1 = require("../../../prompt/src/parse");
 const tokenization_1 = require("../../../prompt/src/tokenization");
 const src_1 = require("../../../types/src");
 const completionNotifier_1 = require("../completionNotifier");
 const config_1 = require("../config");
-const userErrorNotifier_1 = require("../error/userErrorNotifier");
 const featuresService_1 = require("../experiments/featuresService");
 const logger_1 = require("../logger");
 const networking_1 = require("../networking");
 const config_2 = require("../openai/config");
-const fetch_1 = require("../openai/fetch");
-const openai_1 = require("../openai/openai");
 const progress_1 = require("../progress");
 const contextProviderBridge_1 = require("../prompt/components/contextProviderBridge");
 const contextProviderStatistics_1 = require("../prompt/contextProviderStatistics");
@@ -32,787 +34,421 @@ const suggestions_1 = require("../suggestions/suggestions");
 const telemetry_2 = require("../telemetry");
 const textDocument_1 = require("../textDocument");
 const async_1 = require("../util/async");
-const runtimeMode_1 = require("../util/runtimeMode");
 const asyncCompletions_1 = require("./asyncCompletions");
 const blockTrimmer_1 = require("./blockTrimmer");
 const completionsCache_1 = require("./completionsCache");
-const configBlockMode_1 = require("./configBlockMode");
+const completionsFromNetwork_1 = require("./completionsFromNetwork");
 const current_1 = require("./current");
-const multilineModel_1 = require("./multilineModel");
-const streamedCompletionSplitter_1 = require("./streamedCompletionSplitter");
+const ghostTextStrategy_1 = require("./ghostTextStrategy");
+const resultType_1 = require("./resultType");
 const telemetry_3 = require("./telemetry");
-const ghostTextLogger = new logger_1.Logger('ghostText');
-var ResultType;
-(function (ResultType) {
-    ResultType[ResultType["Network"] = 0] = "Network";
-    ResultType[ResultType["Cache"] = 1] = "Cache";
-    ResultType[ResultType["TypingAsSuggested"] = 2] = "TypingAsSuggested";
-    ResultType[ResultType["Cycling"] = 3] = "Cycling";
-    ResultType[ResultType["Async"] = 4] = "Async";
-})(ResultType || (exports.ResultType = ResultType = {}));
-// p50 line length is 19 characters (p95 is 73)
-// average token length is around 4 characters
-// the below values have quite a bit of buffer while bringing the limit in significantly from 500
-const maxSinglelineTokens = 20;
-async function genericGetCompletionsFromNetwork(accessor, requestContext, baseTelemetryData, cancellationToken, finishedCb, what, processChoices) {
+const defaultOptions = {
+    isCycling: false,
+    promptOnly: false,
+    isSpeculative: false,
+};
+function getRemainingDebounceMs(accessor, opts, telemetry) {
     const featuresService = accessor.get(featuresService_1.ICompletionsFeaturesService);
-    const fetcherService = accessor.get(fetch_1.ICompletionsOpenAIFetcherService);
-    const runtimeMode = accessor.get(runtimeMode_1.ICompletionsRuntimeModeService);
-    const instantiationService = accessor.get(instantiation_1.IInstantiationService);
-    const logTarget = accessor.get(logger_1.ICompletionsLogTargetService);
-    const userErrorNotifier = accessor.get(userErrorNotifier_1.ICompletionsUserErrorNotifierService);
-    ghostTextLogger.debug(logTarget, `Getting ${what} from network`);
-    // copy the base telemetry data
-    baseTelemetryData = baseTelemetryData.extendedBy();
-    // Request one choice for automatic requests, three for invoked (cycling) requests.
-    const n = requestContext.isCycling ? 3 : 1;
-    const temperature = (0, openai_1.getTemperatureForSamples)(runtimeMode, n);
-    const extra = {
-        language: requestContext.languageId,
-        next_indent: requestContext.indentation.next ?? 0,
-        trim_by_indentation: (0, config_1.shouldDoServerTrimming)(requestContext.blockMode),
-        prompt_tokens: requestContext.prompt.prefixTokens ?? 0,
-        suffix_tokens: requestContext.prompt.suffixTokens ?? 0,
-    };
-    const postOptions = { n, temperature, code_annotations: false };
-    const modelTerminatesSingleline = featuresService.modelAlwaysTerminatesSingleline(baseTelemetryData);
-    const simulateSingleline = requestContext.blockMode === config_1.BlockMode.MoreMultiline &&
-        blockTrimmer_1.BlockTrimmer.isSupported(requestContext.languageId) &&
-        !modelTerminatesSingleline;
-    if (!requestContext.multiline && !simulateSingleline) {
-        // If we are not in multiline mode, we get the server to truncate the results. This does mean that we
-        // also cache a single line result which will be reused even if we are later in multiline mode. This is
-        // an acceptable trade-off as the transition should be relatively rare and truncating on the server is
-        // more efficient.
-        // Note that this also means we don't need to truncate when creating the GhostAPIChoice object below.
-        postOptions['stop'] = ['\n'];
-    }
-    else if (requestContext.stop) {
-        postOptions['stop'] = requestContext.stop;
-    }
-    if (requestContext.maxTokens !== undefined) {
-        postOptions['max_tokens'] = requestContext.maxTokens;
+    const debounce = (0, config_1.getConfig)(accessor, config_1.ConfigKey.CompletionsDebounce) ??
+        featuresService.completionsDebounce(telemetry) ??
+        opts.debounceMs;
+    if (debounce === undefined) {
+        return 0;
     }
-    const requestStart = Date.now();
-    // extend telemetry data
-    const newProperties = {
-        endpoint: 'completions',
-        uiKind: fetch_1.CopilotUiKind.GhostText,
-        temperature: JSON.stringify(temperature),
-        n: JSON.stringify(n),
-        stop: JSON.stringify(postOptions['stop']) ?? 'unset',
-        logit_bias: JSON.stringify(null),
-    };
-    Object.assign(baseTelemetryData.properties, newProperties);
-    try {
-        const completionParams = {
-            prompt: requestContext.prompt,
-            languageId: requestContext.languageId,
-            repoInfo: requestContext.repoInfo,
-            ourRequestId: requestContext.ourRequestId,
-            engineModelId: requestContext.engineModelId,
-            count: n,
-            uiKind: fetch_1.CopilotUiKind.GhostText,
-            postOptions,
-            headers: requestContext.headers,
-            extra,
-        };
-        const res = await fetcherService.fetchAndStreamCompletions(completionParams, baseTelemetryData, finishedCb, cancellationToken);
-        if (res.type === 'failed') {
-            return {
-                type: 'failed',
-                reason: res.reason,
-                telemetryData: (0, telemetry_3.mkBasicResultTelemetry)(baseTelemetryData),
-            };
+    const elapsed = (0, telemetry_2.now)() - telemetry.issuedTime;
+    return Math.max(0, debounce - elapsed);
+}
+function isCompletionRequestCancelled(currentGhostText, requestId, cancellationToken) {
+    return cancellationToken?.isCancellationRequested || requestId !== currentGhostText.currentRequestId;
+}
+let GhostTextComputer = class GhostTextComputer {
+    constructor(instantiationService, telemetryService, notifierService, contextProviderBridge, currentGhostText, contextproviderStatistics, asyncCompletionManager, completionsFeaturesService, logTarget, statusReporter, logService) {
+        this.instantiationService = instantiationService;
+        this.telemetryService = telemetryService;
+        this.notifierService = notifierService;
+        this.contextProviderBridge = contextProviderBridge;
+        this.currentGhostText = currentGhostText;
+        this.contextproviderStatistics = contextproviderStatistics;
+        this.asyncCompletionManager = asyncCompletionManager;
+        this.completionsFeaturesService = completionsFeaturesService;
+        this.logTarget = logTarget;
+        this.statusReporter = statusReporter;
+        this.logService = logService;
+        this.logger = logService.createSubLogger(['ghostText', 'GhostTextComputer']);
+    }
+    async getGhostText(completionState, token, options) {
+        const id = (0, uuid_1.generateUuid)();
+        this.currentGhostText.currentRequestId = id;
+        const telemetryData = await this.instantiationService.invokeFunction(createTelemetryWithExp, completionState.textDocument, id, options);
+        // A CLS consumer has an LSP bug where it erroneously makes method requests before `initialize` has returned, which
+        // means we can't use `initialize` to actually initialize anything expensive.  This the primary user of the
+        // tokenizer, so settle for initializing here instead.  We don't use waitForTokenizers() because in the event of a
+        // tokenizer load failure, that would spam handleException() on every request.
+        await tokenization_1.initializeTokenizers.catch(() => { });
+        try {
+            this.contextProviderBridge.schedule(completionState, id, options?.opportunityId ?? '', telemetryData, token, options);
+            this.notifierService.notifyRequest(completionState, id, telemetryData, token, options);
+            const result = await this.getGhostTextWithoutAbortHandling(completionState, id, telemetryData, token, options);
+            const statistics = this.contextproviderStatistics.getStatisticsForCompletion(id);
+            const opportunityId = options?.opportunityId ?? 'unknown';
+            for (const [providerId, statistic] of statistics.getAllUsageStatistics()) {
+                /* __GDPR__
+                    "context-provider.completion-stats" : {
+                        "owner": "dirkb",
+                        "comment": "Telemetry for copilot inline completion context",
+                        "requestId": { "classification": "SystemMetaData", "purpose": "FeatureInsight", "comment": "The request correlation id" },
+                        "opportunityId": { "classification": "SystemMetaData", "purpose": "FeatureInsight", "comment": "The opportunity id" },
+                        "providerId": { "classification": "SystemMetaData", "purpose": "FeatureInsight", "comment": "The context provider id" },
+                        "resolution": { "classification": "SystemMetaData", "purpose": "FeatureInsight", "comment": "The resolution of the context" },
+                        "usage": { "classification": "SystemMetaData", "purpose": "FeatureInsight", "comment": "How the context was used" },
+                        "usageDetails": { "classification": "SystemMetaData", "purpose": "FeatureInsight", "comment": "Additional details about the usage as a JSON string" }
+                    }
+                */
+                this.telemetryService.sendMSFTTelemetryEvent('context-provider.completion-stats', {
+                    requestId: id,
+                    opportunityId,
+                    providerId,
+                    resolution: statistic.resolution,
+                    usage: statistic.usage,
+                    usageDetails: JSON.stringify(statistic.usageDetails),
+                }, {});
+            }
+            return result;
         }
-        if (res.type === 'canceled') {
-            ghostTextLogger.debug(logTarget, 'Cancelled after awaiting fetchCompletions');
-            return {
-                type: 'canceled',
-                reason: res.reason,
-                telemetryData: (0, telemetry_3.mkCanceledResultTelemetry)(baseTelemetryData),
-            };
+        catch (e) {
+            // The cancellation token may be called after the request is done but while we still process data.
+            // The underlying implementation catches abort errors for specific scenarios but we still have uncovered paths.
+            // To avoid returning an error to the editor, this acts as an fault barrier here.
+            if ((0, networking_1.isAbortError)(e)) {
+                return {
+                    type: 'canceled',
+                    reason: 'aborted at unknown location',
+                    telemetryData: (0, telemetry_3.mkCanceledResultTelemetry)(telemetryData, {
+                        cancelledNetworkRequest: true,
+                    }),
+                };
+            }
+            throw e;
         }
-        return processChoices(requestStart, res.getProcessingTime(), res.choices);
     }
-    catch (err) {
-        // If we cancelled a network request, we don't want to log an error
-        if ((0, networking_1.isAbortError)(err)) {
+    async getGhostTextWithoutAbortHandling(completionState, ourRequestId, preIssuedTelemetryDataWithExp, cancellationToken, options) {
+        let start = preIssuedTelemetryDataWithExp.issuedTime; // Start before getting exp assignments
+        const performanceMetrics = [];
+        /** Internal helper to record performance measurements. Mutates performanceMetrics and start. */
+        function recordPerformance(name) {
+            const next = (0, telemetry_2.now)();
+            performanceMetrics.push([name, next - start]);
+            start = next;
+        }
+        recordPerformance('telemetry');
+        if (isCompletionRequestCancelled(this.currentGhostText, ourRequestId, cancellationToken)) {
             return {
-                type: 'canceled',
-                reason: 'network request aborted',
-                telemetryData: (0, telemetry_3.mkCanceledResultTelemetry)(baseTelemetryData, {
-                    cancelledNetworkRequest: true,
-                }),
+                type: 'abortedBeforeIssued',
+                reason: 'cancelled before extractPrompt',
+                telemetryData: (0, telemetry_3.mkBasicResultTelemetry)(preIssuedTelemetryDataWithExp),
             };
         }
-        else {
-            instantiationService.invokeFunction(acc => ghostTextLogger.exception(acc, err, `Error on ghost text request`));
-            userErrorNotifier.notifyUser(err);
-            if (runtimeMode.shouldFailForDebugPurposes()) {
-                throw err;
-            }
-            // not including err in this result because it'll end up in standard telemetry
+        const inlineSuggestion = isInlineSuggestion(completionState.textDocument, completionState.position);
+        if (inlineSuggestion === undefined) {
+            this.logger.debug('Breaking, invalid middle of the line');
             return {
-                type: 'failed',
-                reason: 'non-abort error on ghost text request',
-                telemetryData: (0, telemetry_3.mkBasicResultTelemetry)(baseTelemetryData),
+                type: 'abortedBeforeIssued',
+                reason: 'Invalid middle of the line',
+                telemetryData: (0, telemetry_3.mkBasicResultTelemetry)(preIssuedTelemetryDataWithExp),
             };
         }
-    }
-}
-/**
- * Post-proceses a completion choice based on the current request context and existing choices.
- */
-function postProcessChoices(newChoice, requestContext, currentChoices) {
-    if (!currentChoices) {
-        currentChoices = [];
-    }
-    newChoice.completionText = newChoice.completionText.trimEnd();
-    if (!newChoice.completionText) {
-        return undefined;
-    }
-    // Collect only unique displayTexts
-    if (currentChoices.findIndex(v => v.completionText.trim() === newChoice.completionText.trim()) !== -1) {
-        return undefined;
-    }
-    return newChoice;
-}
-/** Requests new completion from OpenAI, should be called if and only if the completions for given prompt were not cached before.
- *  It returns only first completion, additional completions are added to the caches in the background.
- *  Copies from the base telemetry data are used as the basis for each choice's telemetry.
- */
-async function getCompletionsFromNetwork(accessor, requestContext, baseTelemetryData, cancellationToken, finishedCb) {
-    const instantiationService = accessor.get(instantiation_1.IInstantiationService);
-    const logTarget = accessor.get(logger_1.ICompletionsLogTargetService);
-    const runtimeMode = accessor.get(runtimeMode_1.ICompletionsRuntimeModeService);
-    return genericGetCompletionsFromNetwork(accessor, requestContext, baseTelemetryData, cancellationToken, finishedCb, 'completions', async (requestStart, processingTime, choicesStream) => {
-        const choicesIterator = choicesStream[Symbol.asyncIterator]();
-        const firstRes = await choicesIterator.next();
-        if (firstRes.done) {
-            ghostTextLogger.debug(logTarget, 'All choices redacted');
+        const engineInfo = this.instantiationService.invokeFunction(config_2.getEngineRequestInfo, preIssuedTelemetryDataWithExp);
+        const ghostTextOptions = { ...defaultOptions, ...options, tokenizer: engineInfo.tokenizer };
+        const prompt = await this.instantiationService.invokeFunction(prompt_1.extractPrompt, ourRequestId, completionState, preIssuedTelemetryDataWithExp, undefined, ghostTextOptions);
+        recordPerformance('prompt');
+        if (prompt.type === 'copilotContentExclusion') {
+            this.logger.debug('Copilot not available, due to content exclusion');
             return {
-                type: 'empty',
-                reason: 'all choices redacted',
-                telemetryData: (0, telemetry_3.mkBasicResultTelemetry)(baseTelemetryData),
+                type: 'abortedBeforeIssued',
+                reason: 'Copilot not available due to content exclusion',
+                telemetryData: (0, telemetry_3.mkBasicResultTelemetry)(preIssuedTelemetryDataWithExp),
             };
         }
-        if (cancellationToken?.isCancellationRequested) {
-            ghostTextLogger.debug(logTarget, 'Cancelled after awaiting redactedChoices iterator');
+        if (prompt.type === 'contextTooShort') {
+            this.logger.debug('Breaking, not enough context');
             return {
-                type: 'canceled',
-                reason: 'after awaiting redactedChoices iterator',
-                telemetryData: (0, telemetry_3.mkCanceledResultTelemetry)(baseTelemetryData),
+                type: 'abortedBeforeIssued',
+                reason: 'Not enough context',
+                telemetryData: (0, telemetry_3.mkBasicResultTelemetry)(preIssuedTelemetryDataWithExp),
             };
         }
-        const firstChoice = firstRes.value;
-        if (firstChoice === undefined) {
-            // This is probably unreachable given the firstRes.done check above
-            ghostTextLogger.debug(logTarget, 'Got undefined choice from redactedChoices iterator');
+        if (prompt.type === 'promptError') {
+            this.logger.debug('Error while building the prompt');
             return {
-                type: 'empty',
-                reason: 'got undefined choice from redactedChoices iterator',
-                telemetryData: (0, telemetry_3.mkBasicResultTelemetry)(baseTelemetryData),
+                type: 'abortedBeforeIssued',
+                reason: 'Error while building the prompt',
+                telemetryData: (0, telemetry_3.mkBasicResultTelemetry)(preIssuedTelemetryDataWithExp),
             };
         }
-        instantiationService.invokeFunction(telemetryPerformance, 'performance', firstChoice, requestStart, processingTime);
-        ghostTextLogger.debug(logTarget, `Awaited first result, id:  ${firstChoice.choiceIndex}`);
-        // Adds first result to cache
-        const processedFirstChoice = postProcessChoices(firstChoice, requestContext);
-        if (processedFirstChoice) {
-            instantiationService.invokeFunction(appendToCache, requestContext, processedFirstChoice);
-            ghostTextLogger.debug(logTarget, `GhostText first completion (index ${processedFirstChoice?.choiceIndex}): ${JSON.stringify(processedFirstChoice?.completionText)}`);
+        if (ghostTextOptions.promptOnly) {
+            return { type: 'promptOnly', reason: 'Breaking, promptOnly set to true', prompt: prompt };
         }
-        //Create promise for each result, don't `await` it (unless in test mode) but handle asynchronously with `.then()`
-        const cacheDone = (async () => {
-            const apiChoices = processedFirstChoice !== undefined ? [processedFirstChoice] : [];
-            for await (const choice of choicesStream) {
-                if (choice === undefined) {
-                    continue;
-                }
-                ghostTextLogger.debug(logTarget, `GhostText later completion (index ${choice?.choiceIndex}): ${JSON.stringify(choice.completionText)}`);
-                const processedChoice = postProcessChoices(choice, requestContext, apiChoices);
-                if (!processedChoice) {
-                    continue;
-                }
-                apiChoices.push(processedChoice);
-                instantiationService.invokeFunction(appendToCache, requestContext, processedChoice);
-            }
-        })();
-        if (runtimeMode.isRunningInTest()) {
-            await cacheDone;
+        if (prompt.type === 'promptCancelled') {
+            this.logger.debug('Cancelled during extractPrompt');
+            return {
+                type: 'abortedBeforeIssued',
+                reason: 'Cancelled during extractPrompt',
+                telemetryData: (0, telemetry_3.mkBasicResultTelemetry)(preIssuedTelemetryDataWithExp),
+            };
         }
-        if (processedFirstChoice) {
-            // Because we ask the server to stop at \n above, we don't need to force single line here
+        if (prompt.type === 'promptTimeout') {
+            this.logger.debug('Timeout during extractPrompt');
             return {
-                type: 'success',
-                value: [makeGhostAPIChoice(processedFirstChoice, { forceSingleLine: false }), cacheDone],
-                telemetryData: (0, telemetry_3.mkBasicResultTelemetry)(baseTelemetryData),
-                telemetryBlob: baseTelemetryData,
-                resultType: ResultType.Network,
+                type: 'abortedBeforeIssued',
+                reason: 'Timeout',
+                telemetryData: (0, telemetry_3.mkBasicResultTelemetry)(preIssuedTelemetryDataWithExp),
             };
         }
-        else {
+        if (prompt.prompt.prefix.length === 0 && prompt.prompt.suffix.length === 0) {
+            this.logger.debug('Error empty prompt');
             return {
-                type: 'empty',
-                reason: 'got undefined processedFirstChoice',
-                telemetryData: (0, telemetry_3.mkBasicResultTelemetry)(baseTelemetryData),
+                type: 'abortedBeforeIssued',
+                reason: 'Empty prompt',
+                telemetryData: (0, telemetry_3.mkBasicResultTelemetry)(preIssuedTelemetryDataWithExp),
             };
         }
-    });
-}
-/** Requests new completion from OpenAI, should be called if and only if we are in the servers-side termination mode, and it's follow-up cycling request
- *  It returns all requested completions
- *  Copies from the base telemetry data are used as the basis for each choice's telemetry.
- */
-async function getAllCompletionsFromNetwork(accessor, requestContext, baseTelemetryData, cancellationToken, finishedCb) {
-    const logTarget = accessor.get(logger_1.ICompletionsLogTargetService);
-    const instantiationService = accessor.get(instantiation_1.IInstantiationService);
-    return genericGetCompletionsFromNetwork(accessor, requestContext, baseTelemetryData, cancellationToken, finishedCb, 'all completions', async (requestStart, processingTime, choicesStream) => {
-        const apiChoices = [];
-        for await (const choice of choicesStream) {
-            if (cancellationToken?.isCancellationRequested) {
-                ghostTextLogger.debug(logTarget, 'Cancelled after awaiting choices iterator');
+        const debounce = this.instantiationService.invokeFunction(getRemainingDebounceMs, ghostTextOptions, preIssuedTelemetryDataWithExp);
+        if (debounce > 0) {
+            this.logger.debug(`Debouncing ghost text request for ${debounce}ms`);
+            await (0, async_1.delay)(debounce);
+            if (isCompletionRequestCancelled(this.currentGhostText, ourRequestId, cancellationToken)) {
                 return {
-                    type: 'canceled',
-                    reason: 'after awaiting choices iterator',
-                    telemetryData: (0, telemetry_3.mkCanceledResultTelemetry)(baseTelemetryData),
+                    type: 'abortedBeforeIssued',
+                    reason: 'cancelled after debounce',
+                    telemetryData: (0, telemetry_3.mkBasicResultTelemetry)(preIssuedTelemetryDataWithExp),
                 };
             }
-            const processedChoice = postProcessChoices(choice, requestContext, apiChoices);
-            if (!processedChoice) {
-                continue;
-            }
-            apiChoices.push(processedChoice);
-        }
-        //Append results to current completions cache, and network cache
-        if (apiChoices.length > 0) {
-            for (const choice of apiChoices) {
-                instantiationService.invokeFunction(appendToCache, requestContext, choice);
-            }
-            instantiationService.invokeFunction(telemetryPerformance, 'cyclingPerformance', apiChoices[0], requestStart, processingTime);
-        }
-        return {
-            type: 'success',
-            value: [apiChoices, Promise.resolve()],
-            telemetryData: (0, telemetry_3.mkBasicResultTelemetry)(baseTelemetryData),
-            telemetryBlob: baseTelemetryData,
-            resultType: ResultType.Cycling,
-        };
-    });
-}
-function makeGhostAPIChoice(choice, options) {
-    const ghostChoice = { ...choice };
-    if (options.forceSingleLine) {
-        const { completionText } = ghostChoice;
-        // Special case for when completion starts with a newline, don't count that as its own line
-        const initialLineBreak = completionText.match(/^\r?\n/);
-        if (initialLineBreak) {
-            ghostChoice.completionText = initialLineBreak[0] + completionText.split('\n')[1];
-        }
-        else {
-            ghostChoice.completionText = completionText.split('\n')[0];
-        }
-    }
-    return ghostChoice;
-}
-function takeNLines(n) {
-    return (text) => {
-        // If the text is longer than n lines, return the offset.
-        // Checks for n+1 lines because of the leading newline.
-        const lines = text?.split('\n') ?? [];
-        if (lines.length > n + 1) {
-            return lines.slice(0, n + 1).join('\n').length;
         }
-    };
-}
-async function getGhostTextStrategy(accessor, completionState, prefix, prompt, isCycling, inlineSuggestion, hasAcceptedCurrentCompletion, preIssuedTelemetryData) {
-    const instantiationService = accessor.get(instantiation_1.IInstantiationService);
-    const featuresService = accessor.get(featuresService_1.ICompletionsFeaturesService);
-    const blockModeConfig = accessor.get(configBlockMode_1.ICompletionsBlockModeConfig);
-    const multilineAfterAcceptLines = featuresService.multilineAfterAcceptLines(preIssuedTelemetryData);
-    const blockMode = blockModeConfig.forLanguage(completionState.textDocument.detectedLanguageId, preIssuedTelemetryData);
-    switch (blockMode) {
-        case config_1.BlockMode.Server:
-            // Override the server-side trimming after accepting a completion
-            if (hasAcceptedCurrentCompletion) {
-                return {
-                    blockMode: config_1.BlockMode.Parsing,
-                    requestMultiline: true,
-                    finishedCb: takeNLines(multilineAfterAcceptLines),
-                    stop: ['\n\n'],
-                    maxTokens: maxSinglelineTokens * multilineAfterAcceptLines,
-                };
-            }
-            return {
-                blockMode: config_1.BlockMode.Server,
-                requestMultiline: true,
-                finishedCb: _ => undefined,
+        return this.statusReporter.withProgress(async () => {
+            const [prefix] = (0, prompt_1.trimLastLine)(completionState.textDocument.getText(textDocument_1.LocationFactory.range(textDocument_1.LocationFactory.position(0, 0), completionState.position)));
+            const hasAcceptedCurrentCompletion = this.currentGhostText.hasAcceptedCurrentCompletion(prefix, prompt.prompt.suffix);
+            const originalPrompt = prompt.prompt;
+            const ghostTextStrategy = await this.instantiationService.invokeFunction(ghostTextStrategy_1.getGhostTextStrategy, completionState, prefix, prompt, inlineSuggestion, hasAcceptedCurrentCompletion, preIssuedTelemetryDataWithExp);
+            recordPerformance('strategy');
+            let choices = this.instantiationService.invokeFunction(getLocalInlineSuggestion, prefix, originalPrompt, ghostTextStrategy.requestMultiline);
+            recordPerformance('cache');
+            const repoInfo = this.instantiationService.invokeFunction(repository_1.extractRepoInfoInBackground, completionState.textDocument.uri);
+            const requestContext = {
+                blockMode: ghostTextStrategy.blockMode,
+                languageId: completionState.textDocument.detectedLanguageId,
+                repoInfo: repoInfo,
+                engineModelId: engineInfo.modelId,
+                ourRequestId,
+                prefix,
+                prompt: prompt.prompt,
+                multiline: ghostTextStrategy.requestMultiline,
+                indentation: (0, parseBlock_1.contextIndentation)(completionState.textDocument, completionState.position),
+                isCycling: ghostTextOptions.isCycling,
+                headers: engineInfo.headers,
+                stop: ghostTextStrategy.stop,
+                maxTokens: ghostTextStrategy.maxTokens,
+                afterAccept: hasAcceptedCurrentCompletion,
             };
-        case config_1.BlockMode.Parsing:
-        case config_1.BlockMode.ParsingAndServer:
-        case config_1.BlockMode.MoreMultiline:
-        default: {
-            // we shouldn't drop through to here, but in case we do, be explicit about the behaviour
-            let requestMultiline;
-            try {
-                requestMultiline = await instantiationService.invokeFunction(shouldRequestMultiline, blockMode, completionState.textDocument, completionState.position, inlineSuggestion, hasAcceptedCurrentCompletion, prompt);
-            }
-            catch (err) {
-                // Fallback to non-multiline
-                requestMultiline = { requestMultiline: false };
-            }
-            if (!hasAcceptedCurrentCompletion &&
-                requestMultiline.requestMultiline &&
-                featuresService.singleLineUnlessAccepted(preIssuedTelemetryData)) {
-                requestMultiline.requestMultiline = false;
-            }
-            if (requestMultiline.requestMultiline) {
-                // Note that `trailingWs` contains *any* trailing whitespace from the prompt, but the prompt itself
-                // is only trimmed if the entire last line is whitespace.  We have to account for that here when we
-                // check whether the block body is finished.
-                let adjustedPosition;
-                if (prompt.trailingWs.length > 0 && !prompt.prompt.prefix.endsWith(prompt.trailingWs)) {
-                    // Prompt was adjusted, so adjust the position to match
-                    adjustedPosition = textDocument_1.LocationFactory.position(completionState.position.line, Math.max(completionState.position.character - prompt.trailingWs.length, 0));
-                }
-                else {
-                    // Otherwise, just use the original position
-                    adjustedPosition = completionState.position;
+            // Add headers to identify async completions and speculative requests
+            requestContext.headers = {
+                ...requestContext.headers,
+                'X-Copilot-Async': 'true',
+                'X-Copilot-Speculative': ghostTextOptions.isSpeculative ? 'true' : 'false',
+            };
+            // this will be used as basis for the choice telemetry data
+            const telemetryData = this.instantiationService.invokeFunction(telemetryIssued, completionState.textDocument, requestContext, completionState.position, prompt, preIssuedTelemetryDataWithExp, engineInfo, ghostTextOptions);
+            // Wait before requesting more completions if there is a candidate
+            // completion request in flight. Does not wait for cycling requests or
+            // if there is a cached completion.
+            if (choices === undefined &&
+                !ghostTextOptions.isCycling &&
+                this.asyncCompletionManager.shouldWaitForAsyncCompletions(prefix, prompt.prompt)) {
+                const choice = await this.asyncCompletionManager.getFirstMatchingRequestWithTimeout(ourRequestId, prefix, prompt.prompt, ghostTextOptions.isSpeculative, telemetryData);
+                recordPerformance('asyncWait');
+                if (choice) {
+                    const forceSingleLine = !ghostTextStrategy.requestMultiline;
+                    const trimmedChoice = (0, completionsFromNetwork_1.makeGhostAPIChoice)(choice[0], { forceSingleLine });
+                    choices = [[trimmedChoice], resultType_1.ResultType.Async];
                 }
-                return {
-                    blockMode: blockMode,
-                    requestMultiline: true,
-                    ...instantiationService.invokeFunction(buildFinishedCallback, blockMode, completionState.textDocument, adjustedPosition, requestMultiline.blockPosition, prefix, true, prompt.prompt, preIssuedTelemetryData),
-                };
-            }
-            // Override single-line to multiline after accepting a completion
-            if (hasAcceptedCurrentCompletion) {
-                const result = {
-                    blockMode: config_1.BlockMode.Parsing,
-                    requestMultiline: true,
-                    finishedCb: takeNLines(multilineAfterAcceptLines),
-                    stop: ['\n\n'],
-                    maxTokens: maxSinglelineTokens * multilineAfterAcceptLines,
-                };
-                if (blockMode === config_1.BlockMode.MoreMultiline) {
-                    result.blockMode = config_1.BlockMode.MoreMultiline;
+                if (isCompletionRequestCancelled(this.currentGhostText, ourRequestId, cancellationToken)) {
+                    this.logger.debug('Cancelled before requesting a new completion');
+                    return {
+                        type: 'abortedBeforeIssued',
+                        reason: 'Cancelled after waiting for async completion',
+                        telemetryData: (0, telemetry_3.mkBasicResultTelemetry)(telemetryData),
+                    };
                 }
-                return result;
             }
-            // not multiline
-            return {
-                blockMode: blockMode,
-                requestMultiline: false,
-                ...instantiationService.invokeFunction(buildFinishedCallback, blockMode, completionState.textDocument, completionState.position, requestMultiline.blockPosition, prefix, false, prompt.prompt, preIssuedTelemetryData),
-            };
-        }
-    }
-}
-function buildFinishedCallback(accessor, blockMode, document, position, positionType, prefix, multiline, prompt, telemetryData) {
-    const featuresService = accessor.get(featuresService_1.ICompletionsFeaturesService);
-    const instantiationService = accessor.get(instantiation_1.IInstantiationService);
-    if (multiline && blockMode === config_1.BlockMode.MoreMultiline && blockTrimmer_1.BlockTrimmer.isSupported(document.detectedLanguageId)) {
-        const lookAhead = positionType === blockTrimmer_1.BlockPositionType.EmptyBlock || positionType === blockTrimmer_1.BlockPositionType.BlockEnd
-            ? featuresService.longLookaheadSize(telemetryData)
-            : featuresService.shortLookaheadSize(telemetryData);
-        const finishedCb = instantiationService.createInstance(streamedCompletionSplitter_1.StreamedCompletionSplitter, prefix, document.detectedLanguageId, false, lookAhead, (extraPrefix, item) => {
-            const cacheContext = {
-                prefix: prefix + extraPrefix,
-                prompt: { ...prompt, prefix: prompt.prefix + extraPrefix },
-            };
-            instantiationService.invokeFunction(appendToCache, cacheContext, item);
-        }).getFinishedCallback();
-        return {
-            finishedCb,
-            maxTokens: featuresService.maxMultilineTokens(telemetryData),
-        };
-    }
-    return { finishedCb: multiline ? (0, parseBlock_1.parsingBlockFinished)(document, position) : _ => undefined };
-}
-const defaultOptions = {
-    isCycling: false,
-    promptOnly: false,
-    isSpeculative: false,
-};
-function getRemainingDebounceMs(accessor, opts, telemetry) {
-    const featuresService = accessor.get(featuresService_1.ICompletionsFeaturesService);
-    const debounce = (0, config_1.getConfig)(accessor, config_1.ConfigKey.CompletionsDebounce) ??
-        featuresService.completionsDebounce(telemetry) ??
-        opts.debounceMs;
-    if (debounce === undefined) {
-        return 0;
-    }
-    const elapsed = (0, telemetry_2.now)() - telemetry.issuedTime;
-    return Math.max(0, debounce - elapsed);
-}
-function inlineCompletionRequestCancelled(currentGhostText, requestId, cancellationToken) {
-    return cancellationToken?.isCancellationRequested || requestId !== currentGhostText.currentRequestId;
-}
-async function getGhostTextWithoutAbortHandling(accessor, completionState, ourRequestId, preIssuedTelemetryDataWithExp, cancellationToken, options) {
-    let start = preIssuedTelemetryDataWithExp.issuedTime; // Start before getting exp assignments
-    const performanceMetrics = [];
-    /** Internal helper to record performance measurements. Mutates performanceMetrics and start. */
-    function recordPerformance(name) {
-        const next = (0, telemetry_2.now)();
-        performanceMetrics.push([name, next - start]);
-        start = next;
-    }
-    recordPerformance('telemetry');
-    const instantiationService = accessor.get(instantiation_1.IInstantiationService);
-    const featuresService = accessor.get(featuresService_1.ICompletionsFeaturesService);
-    const asyncCompletionManager = accessor.get(asyncCompletions_1.ICompletionsAsyncManagerService);
-    const logTarget = accessor.get(logger_1.ICompletionsLogTargetService);
-    const currentGhostText = accessor.get(current_1.ICompletionsCurrentGhostText);
-    const statusReporter = accessor.get(progress_1.ICompletionsStatusReporter);
-    if (inlineCompletionRequestCancelled(currentGhostText, ourRequestId, cancellationToken)) {
-        return {
-            type: 'abortedBeforeIssued',
-            reason: 'cancelled before extractPrompt',
-            telemetryData: (0, telemetry_3.mkBasicResultTelemetry)(preIssuedTelemetryDataWithExp),
-        };
-    }
-    const inlineSuggestion = isInlineSuggestion(completionState.textDocument, completionState.position);
-    if (inlineSuggestion === undefined) {
-        ghostTextLogger.debug(logTarget, 'Breaking, invalid middle of the line');
-        return {
-            type: 'abortedBeforeIssued',
-            reason: 'Invalid middle of the line',
-            telemetryData: (0, telemetry_3.mkBasicResultTelemetry)(preIssuedTelemetryDataWithExp),
-        };
-    }
-    const engineInfo = instantiationService.invokeFunction(config_2.getEngineRequestInfo, preIssuedTelemetryDataWithExp);
-    const ghostTextOptions = { ...defaultOptions, ...options, tokenizer: engineInfo.tokenizer };
-    const prompt = await instantiationService.invokeFunction(prompt_1.extractPrompt, ourRequestId, completionState, preIssuedTelemetryDataWithExp, undefined, ghostTextOptions);
-    recordPerformance('prompt');
-    if (prompt.type === 'copilotContentExclusion') {
-        ghostTextLogger.debug(logTarget, 'Copilot not available, due to content exclusion');
-        return {
-            type: 'abortedBeforeIssued',
-            reason: 'Copilot not available due to content exclusion',
-            telemetryData: (0, telemetry_3.mkBasicResultTelemetry)(preIssuedTelemetryDataWithExp),
-        };
-    }
-    if (prompt.type === 'contextTooShort') {
-        ghostTextLogger.debug(logTarget, 'Breaking, not enough context');
-        return {
-            type: 'abortedBeforeIssued',
-            reason: 'Not enough context',
-            telemetryData: (0, telemetry_3.mkBasicResultTelemetry)(preIssuedTelemetryDataWithExp),
-        };
-    }
-    if (prompt.type === 'promptError') {
-        ghostTextLogger.debug(logTarget, 'Error while building the prompt');
-        return {
-            type: 'abortedBeforeIssued',
-            reason: 'Error while building the prompt',
-            telemetryData: (0, telemetry_3.mkBasicResultTelemetry)(preIssuedTelemetryDataWithExp),
-        };
-    }
-    if (ghostTextOptions.promptOnly) {
-        return { type: 'promptOnly', reason: 'Breaking, promptOnly set to true', prompt: prompt };
-    }
-    if (prompt.type === 'promptCancelled') {
-        ghostTextLogger.debug(logTarget, 'Cancelled during extractPrompt');
-        return {
-            type: 'abortedBeforeIssued',
-            reason: 'Cancelled during extractPrompt',
-            telemetryData: (0, telemetry_3.mkBasicResultTelemetry)(preIssuedTelemetryDataWithExp),
-        };
-    }
-    if (prompt.type === 'promptTimeout') {
-        ghostTextLogger.debug(logTarget, 'Timeout during extractPrompt');
-        return {
-            type: 'abortedBeforeIssued',
-            reason: 'Timeout',
-            telemetryData: (0, telemetry_3.mkBasicResultTelemetry)(preIssuedTelemetryDataWithExp),
-        };
-    }
-    if (prompt.prompt.prefix.length === 0 && prompt.prompt.suffix.length === 0) {
-        ghostTextLogger.debug(logTarget, 'Error empty prompt');
-        return {
-            type: 'abortedBeforeIssued',
-            reason: 'Empty prompt',
-            telemetryData: (0, telemetry_3.mkBasicResultTelemetry)(preIssuedTelemetryDataWithExp),
-        };
-    }
-    const debounce = instantiationService.invokeFunction(getRemainingDebounceMs, ghostTextOptions, preIssuedTelemetryDataWithExp);
-    if (debounce > 0) {
-        ghostTextLogger.debug(logTarget, `Debouncing ghost text request for ${debounce}ms`);
-        await (0, async_1.delay)(debounce);
-        if (inlineCompletionRequestCancelled(currentGhostText, ourRequestId, cancellationToken)) {
-            return {
-                type: 'abortedBeforeIssued',
-                reason: 'cancelled after debounce',
-                telemetryData: (0, telemetry_3.mkBasicResultTelemetry)(preIssuedTelemetryDataWithExp),
-            };
-        }
-    }
-    return statusReporter.withProgress(async () => {
-        const [prefix] = (0, prompt_1.trimLastLine)(completionState.textDocument.getText(textDocument_1.LocationFactory.range(textDocument_1.LocationFactory.position(0, 0), completionState.position)));
-        const hasAcceptedCurrentCompletion = currentGhostText.hasAcceptedCurrentCompletion(prefix, prompt.prompt.suffix);
-        const originalPrompt = prompt.prompt;
-        const ghostTextStrategy = await instantiationService.invokeFunction(getGhostTextStrategy, completionState, prefix, prompt, ghostTextOptions.isCycling, inlineSuggestion, hasAcceptedCurrentCompletion, preIssuedTelemetryDataWithExp);
-        recordPerformance('strategy');
-        let choices = instantiationService.invokeFunction(getLocalInlineSuggestion, prefix, originalPrompt, ghostTextStrategy.requestMultiline);
-        recordPerformance('cache');
-        const repoInfo = instantiationService.invokeFunction(repository_1.extractRepoInfoInBackground, completionState.textDocument.uri);
-        const requestContext = {
-            blockMode: ghostTextStrategy.blockMode,
-            languageId: completionState.textDocument.detectedLanguageId,
-            repoInfo: repoInfo,
-            engineModelId: engineInfo.modelId,
-            ourRequestId,
-            prefix,
-            prompt: prompt.prompt,
-            multiline: ghostTextStrategy.requestMultiline,
-            indentation: (0, parseBlock_1.contextIndentation)(completionState.textDocument, completionState.position),
-            isCycling: ghostTextOptions.isCycling,
-            headers: engineInfo.headers,
-            stop: ghostTextStrategy.stop,
-            maxTokens: ghostTextStrategy.maxTokens,
-            afterAccept: hasAcceptedCurrentCompletion,
-        };
-        // Add headers to identify async completions and speculative requests
-        requestContext.headers = {
-            ...requestContext.headers,
-            'X-Copilot-Async': 'true',
-            'X-Copilot-Speculative': ghostTextOptions.isSpeculative ? 'true' : 'false',
-        };
-        // this will be used as basis for the choice telemetry data
-        const telemetryData = instantiationService.invokeFunction(telemetryIssued, completionState.textDocument, requestContext, completionState.position, prompt, preIssuedTelemetryDataWithExp, engineInfo, ghostTextOptions);
-        // Wait before requesting more completions if there is a candidate
-        // completion request in flight. Does not wait for cycling requests or
-        // if there is a cached completion.
-        if (choices === undefined &&
-            !ghostTextOptions.isCycling &&
-            asyncCompletionManager.shouldWaitForAsyncCompletions(prefix, prompt.prompt)) {
-            const choice = await asyncCompletionManager.getFirstMatchingRequestWithTimeout(ourRequestId, prefix, prompt.prompt, ghostTextOptions.isSpeculative, telemetryData);
-            recordPerformance('asyncWait');
-            if (choice) {
-                const forceSingleLine = !ghostTextStrategy.requestMultiline;
-                const trimmedChoice = makeGhostAPIChoice(choice[0], { forceSingleLine });
-                choices = [[trimmedChoice], ResultType.Async];
+            const isMoreMultiline = ghostTextStrategy.blockMode === config_1.BlockMode.MoreMultiline &&
+                blockTrimmer_1.BlockTrimmer.isSupported(completionState.textDocument.detectedLanguageId);
+            if (choices !== undefined) {
+                // Post-process any cached choices before deciding whether to issue a network request
+                choices[0] = choices[0]
+                    .map(c => this.instantiationService.invokeFunction(suggestions_1.postProcessChoiceInContext, completionState.textDocument, completionState.position, c, isMoreMultiline, this.logger))
+                    .filter(c => c !== undefined);
             }
-            if (inlineCompletionRequestCancelled(currentGhostText, ourRequestId, cancellationToken)) {
-                ghostTextLogger.debug(logTarget, 'Cancelled before requesting a new completion');
+            if (choices !== undefined && choices[0].length === 0) {
+                this.logger.debug(`Found empty inline suggestions locally via ${(0, telemetry_3.resultTypeToString)(choices[1])}`);
                 return {
-                    type: 'abortedBeforeIssued',
-                    reason: 'Cancelled after waiting for async completion',
+                    type: 'empty',
+                    reason: 'cached results empty after post-processing',
                     telemetryData: (0, telemetry_3.mkBasicResultTelemetry)(telemetryData),
                 };
             }
-        }
-        const isMoreMultiline = ghostTextStrategy.blockMode === config_1.BlockMode.MoreMultiline &&
-            blockTrimmer_1.BlockTrimmer.isSupported(completionState.textDocument.detectedLanguageId);
-        if (choices !== undefined) {
-            // Post-process any cached choices before deciding whether to issue a network request
-            choices[0] = choices[0]
-                .map(c => instantiationService.invokeFunction(suggestions_1.postProcessChoiceInContext, completionState.textDocument, completionState.position, c, isMoreMultiline, ghostTextLogger))
-                .filter(c => c !== undefined);
-        }
-        if (choices !== undefined && choices[0].length === 0) {
-            ghostTextLogger.debug(logTarget, `Found empty inline suggestions locally via ${(0, telemetry_3.resultTypeToString)(choices[1])}`);
-            return {
-                type: 'empty',
-                reason: 'cached results empty after post-processing',
-                telemetryData: (0, telemetry_3.mkBasicResultTelemetry)(telemetryData),
-            };
-        }
-        if (choices !== undefined &&
-            choices[0].length > 0 &&
-            // If it's a cycling request, need to show multiple choices
-            (!ghostTextOptions.isCycling || choices[0].length > 1)) {
-            ghostTextLogger.debug(logTarget, `Found inline suggestions locally via ${(0, telemetry_3.resultTypeToString)(choices[1])}`);
-        }
-        else {
-            // No local choices, go to network
-            if (ghostTextOptions.isCycling) {
-                const networkChoices = await instantiationService.invokeFunction(getAllCompletionsFromNetwork, requestContext, telemetryData, cancellationToken, ghostTextStrategy.finishedCb);
-                // TODO: if we already had some choices cached from the initial non-cycling request,
-                // and then the cycling request returns no results for some reason, we need to still
-                // return the original choices to the editor to avoid the ghost text disappearing completely.
-                // However this should be telemetrised according to the result of the cycling request itself,
-                // i.e. failure/empty (or maybe canceled).
-                //
-                // Right now this is awkward to orchestrate in the code and we don't handle it, incorrectly
-                // returning `ghostText.produced` instead. Cycling is a manual action and hence uncommon,
-                // so this shouldn't cause much inaccuracy, but we still should fix this.
-                if (networkChoices.type === 'success') {
-                    const resultChoices = choices?.[0] ?? [];
-                    networkChoices.value[0].forEach(c => {
-                        // Collect only unique displayTexts
-                        if (resultChoices.findIndex(v => v.completionText.trim() === c.completionText.trim()) !== -1) {
-                            return;
+            if (choices !== undefined &&
+                choices[0].length > 0 &&
+                // If it's a cycling request, need to show multiple choices
+                (!ghostTextOptions.isCycling || choices[0].length > 1)) {
+                this.logger.debug(`Found inline suggestions locally via ${(0, telemetry_3.resultTypeToString)(choices[1])}`);
+            }
+            else {
+                // No local choices, go to network
+                const completionsFromNetwork = this.instantiationService.createInstance(completionsFromNetwork_1.CompletionsFromNetwork);
+                if (ghostTextOptions.isCycling) {
+                    const networkChoices = await completionsFromNetwork.getAllCompletionsFromNetwork(requestContext, telemetryData, cancellationToken, ghostTextStrategy.finishedCb);
+                    // TODO: if we already had some choices cached from the initial non-cycling request,
+                    // and then the cycling request returns no results for some reason, we need to still
+                    // return the original choices to the editor to avoid the ghost text disappearing completely.
+                    // However this should be telemetrised according to the result of the cycling request itself,
+                    // i.e. failure/empty (or maybe canceled).
+                    //
+                    // Right now this is awkward to orchestrate in the code and we don't handle it, incorrectly
+                    // returning `ghostText.produced` instead. Cycling is a manual action and hence uncommon,
+                    // so this shouldn't cause much inaccuracy, but we still should fix this.
+                    if (networkChoices.type === 'success') {
+                        const resultChoices = choices?.[0] ?? [];
+                        networkChoices.value[0].forEach(c => {
+                            // Collect only unique displayTexts
+                            if (resultChoices.findIndex(v => v.completionText.trim() === c.completionText.trim()) !== -1) {
+                                return;
+                            }
+                            resultChoices.push(c);
+                        });
+                        choices = [resultChoices, resultType_1.ResultType.Cycling];
+                    }
+                    else {
+                        if (choices === undefined) {
+                            return networkChoices;
                         }
-                        resultChoices.push(c);
-                    });
-                    choices = [resultChoices, ResultType.Cycling];
+                    }
                 }
                 else {
-                    if (choices === undefined) {
-                        return networkChoices;
+                    // Wrap an observer around the finished callback to update the
+                    // async manager as the request streams in.
+                    const finishedCb = (text, delta) => {
+                        this.asyncCompletionManager.updateCompletion(ourRequestId, text);
+                        return ghostTextStrategy.finishedCb(text, delta);
+                    };
+                    const asyncCancellationTokenSource = new src_1.CancellationTokenSource();
+                    const requestPromise = completionsFromNetwork.getCompletionsFromNetwork(requestContext, telemetryData, asyncCancellationTokenSource.token, finishedCb);
+                    void this.asyncCompletionManager.queueCompletionRequest(ourRequestId, prefix, prompt.prompt, asyncCancellationTokenSource, requestPromise);
+                    const c = await this.asyncCompletionManager.getFirstMatchingRequest(ourRequestId, prefix, prompt.prompt, ghostTextOptions.isSpeculative);
+                    if (c === undefined) {
+                        return {
+                            type: 'empty',
+                            reason: 'received no results from async completions',
+                            telemetryData: (0, telemetry_3.mkBasicResultTelemetry)(telemetryData),
+                        };
                     }
+                    choices = [[c[0]], resultType_1.ResultType.Async];
                 }
+                recordPerformance('network');
             }
-            else {
-                // Wrap an observer around the finished callback to update the
-                // async manager as the request streams in.
-                const finishedCb = (text, delta) => {
-                    asyncCompletionManager.updateCompletion(ourRequestId, text);
-                    return ghostTextStrategy.finishedCb(text, delta);
+            if (choices === undefined) {
+                return {
+                    type: 'failed',
+                    reason: 'internal error: choices should be defined after network call',
+                    telemetryData: (0, telemetry_3.mkBasicResultTelemetry)(telemetryData),
                 };
-                const asyncCancellationTokenSource = new src_1.CancellationTokenSource();
-                const requestPromise = instantiationService.invokeFunction(getCompletionsFromNetwork, requestContext, telemetryData, asyncCancellationTokenSource.token, finishedCb);
-                void asyncCompletionManager.queueCompletionRequest(ourRequestId, prefix, prompt.prompt, asyncCancellationTokenSource, requestPromise);
-                const c = await asyncCompletionManager.getFirstMatchingRequest(ourRequestId, prefix, prompt.prompt, ghostTextOptions.isSpeculative);
-                if (c === undefined) {
+            }
+            const [choicesArray, resultType] = choices;
+            const postProcessedChoicesArray = choicesArray
+                .map(c => this.instantiationService.invokeFunction(suggestions_1.postProcessChoiceInContext, completionState.textDocument, completionState.position, c, isMoreMultiline, this.logger))
+                .filter(c => c !== undefined);
+            // Delay response if needed. Note, this must come before the
+            // telemetryWithAddData call since the time_to_produce_ms is computed
+            // there
+            const completionsDelay = this.instantiationService.invokeFunction((config_1.getConfig), config_1.ConfigKey.CompletionsDelay) ??
+                this.completionsFeaturesService.completionsDelay(preIssuedTelemetryDataWithExp);
+            const elapsed = (0, telemetry_2.now)() - preIssuedTelemetryDataWithExp.issuedTime;
+            const remainingDelay = Math.max(completionsDelay - elapsed, 0);
+            if (resultType !== resultType_1.ResultType.TypingAsSuggested && !ghostTextOptions.isCycling && remainingDelay > 0) {
+                this.logger.debug(`Waiting ${remainingDelay}ms before returning completion`);
+                await (0, async_1.delay)(remainingDelay);
+                if (isCompletionRequestCancelled(this.currentGhostText, ourRequestId, cancellationToken)) {
+                    this.logger.debug('Cancelled after completions delay');
                     return {
-                        type: 'empty',
-                        reason: 'received no results from async completions',
-                        telemetryData: (0, telemetry_3.mkBasicResultTelemetry)(telemetryData),
+                        type: 'canceled',
+                        reason: 'after completions delay',
+                        telemetryData: (0, telemetry_3.mkCanceledResultTelemetry)(telemetryData),
                     };
                 }
-                choices = [[c[0]], ResultType.Async];
             }
-            recordPerformance('network');
-        }
-        if (choices === undefined) {
-            return {
-                type: 'failed',
-                reason: 'internal error: choices should be defined after network call',
-                telemetryData: (0, telemetry_3.mkBasicResultTelemetry)(telemetryData),
-            };
-        }
-        const [choicesArray, resultType] = choices;
-        const postProcessedChoicesArray = choicesArray
-            .map(c => instantiationService.invokeFunction(suggestions_1.postProcessChoiceInContext, completionState.textDocument, completionState.position, c, isMoreMultiline, ghostTextLogger))
-            .filter(c => c !== undefined);
-        // Delay response if needed. Note, this must come before the
-        // telemetryWithAddData call since the time_to_produce_ms is computed
-        // there
-        const completionsDelay = instantiationService.invokeFunction((config_1.getConfig), config_1.ConfigKey.CompletionsDelay) ??
-            featuresService.completionsDelay(preIssuedTelemetryDataWithExp);
-        const elapsed = (0, telemetry_2.now)() - preIssuedTelemetryDataWithExp.issuedTime;
-        const remainingDelay = Math.max(completionsDelay - elapsed, 0);
-        if (resultType !== ResultType.TypingAsSuggested && !ghostTextOptions.isCycling && remainingDelay > 0) {
-            ghostTextLogger.debug(logTarget, `Waiting ${remainingDelay}ms before returning completion`);
-            await (0, async_1.delay)(remainingDelay);
-            if (inlineCompletionRequestCancelled(currentGhostText, ourRequestId, cancellationToken)) {
-                ghostTextLogger.debug(logTarget, 'Cancelled after completions delay');
+            const results = [];
+            for (const choice of postProcessedChoicesArray) {
+                // Do this to get a new object for each choice
+                const choiceTelemetryData = telemetryWithAddData(completionState.textDocument, requestContext, choice, telemetryData);
+                const suffixCoverage = inlineSuggestion
+                    ? (0, suggestions_1.checkSuffix)(completionState.textDocument, completionState.position, choice)
+                    : 0;
+                // We want to use `newTrailingWs` as the trailing whitespace
+                const ghostCompletion = adjustLeadingWhitespace(choice.choiceIndex, choice.completionText, prompt.trailingWs);
+                const res = {
+                    completion: ghostCompletion,
+                    telemetry: choiceTelemetryData,
+                    isMiddleOfTheLine: inlineSuggestion,
+                    suffixCoverage,
+                    copilotAnnotations: choice.copilotAnnotations,
+                    clientCompletionId: choice.clientCompletionId,
+                };
+                results.push(res);
+            }
+            // Lift clientCompletionId out of the result in order to include it in the telemetry payload computed by mkBasicResultTelemetry.
+            telemetryData.properties.clientCompletionId = results[0]?.clientCompletionId;
+            // If reading from the cache or async, capture the look back offset used
+            telemetryData.measurements.foundOffset = results?.[0]?.telemetry?.measurements?.foundOffset ?? -1;
+            this.logger.debug(`Produced ${results.length} results from ${(0, telemetry_3.resultTypeToString)(resultType)} at ${telemetryData.measurements.foundOffset} offset`);
+            if (isCompletionRequestCancelled(this.currentGhostText, ourRequestId, cancellationToken)) {
                 return {
                     type: 'canceled',
-                    reason: 'after completions delay',
+                    reason: 'after post processing completions',
                     telemetryData: (0, telemetry_3.mkCanceledResultTelemetry)(telemetryData),
                 };
             }
-        }
-        const results = [];
-        for (const choice of postProcessedChoicesArray) {
-            // Do this to get a new object for each choice
-            const choiceTelemetryData = telemetryWithAddData(completionState.textDocument, requestContext, choice, telemetryData);
-            const suffixCoverage = inlineSuggestion
-                ? (0, suggestions_1.checkSuffix)(completionState.textDocument, completionState.position, choice)
-                : 0;
-            // We want to use `newTrailingWs` as the trailing whitespace
-            const ghostCompletion = adjustLeadingWhitespace(choice.choiceIndex, choice.completionText, prompt.trailingWs);
-            const res = {
-                completion: ghostCompletion,
-                telemetry: choiceTelemetryData,
-                isMiddleOfTheLine: inlineSuggestion,
-                suffixCoverage,
-                copilotAnnotations: choice.copilotAnnotations,
-                clientCompletionId: choice.clientCompletionId,
-            };
-            results.push(res);
-        }
-        // Lift clientCompletionId out of the result in order to include it in the telemetry payload computed by mkBasicResultTelemetry.
-        telemetryData.properties.clientCompletionId = results[0]?.clientCompletionId;
-        // If reading from the cache or async, capture the look back offset used
-        telemetryData.measurements.foundOffset = results?.[0]?.telemetry?.measurements?.foundOffset ?? -1;
-        ghostTextLogger.debug(logTarget, `Produced ${results.length} results from ${(0, telemetry_3.resultTypeToString)(resultType)} at ${telemetryData.measurements.foundOffset} offset`);
-        if (inlineCompletionRequestCancelled(currentGhostText, ourRequestId, cancellationToken)) {
-            return {
-                type: 'canceled',
-                reason: 'after post processing completions',
-                telemetryData: (0, telemetry_3.mkCanceledResultTelemetry)(telemetryData),
-            };
-        }
-        if (!ghostTextOptions.isSpeculative) {
-            // Update the current ghost text with the new response before returning for the "typing as suggested" UX
-            currentGhostText.setGhostText(prefix, prompt.prompt.suffix, postProcessedChoicesArray, resultType);
-        }
-        recordPerformance('complete');
-        return {
-            type: 'success',
-            value: [results, resultType],
-            telemetryData: (0, telemetry_3.mkBasicResultTelemetry)(telemetryData),
-            telemetryBlob: telemetryData,
-            resultType,
-            performanceMetrics,
-        };
-    });
-}
-async function getGhostText(accessor, completionState, token, options) {
-    const id = (0, uuid_1.generateUuid)();
-    const instantiationService = accessor.get(instantiation_1.IInstantiationService);
-    const telemetryService = accessor.get(telemetry_1.ITelemetryService);
-    const notifierService = accessor.get(completionNotifier_1.ICompletionsNotifierService);
-    const contextProviderBridge = accessor.get(contextProviderBridge_1.ICompletionsContextProviderBridgeService);
-    const currentGhostText = accessor.get(current_1.ICompletionsCurrentGhostText);
-    const contextproviderStatistics = accessor.get(contextProviderStatistics_1.ICompletionsContextProviderService);
-    currentGhostText.currentRequestId = id;
-    const telemetryData = await createTelemetryWithExp(accessor, completionState.textDocument, id, options);
-    // A CLS consumer has an LSP bug where it erroneously makes method requests before `initialize` has returned, which
-    // means we can't use `initialize` to actually initialize anything expensive.  This the primary user of the
-    // tokenizer, so settle for initializing here instead.  We don't use waitForTokenizers() because in the event of a
-    // tokenizer load failure, that would spam handleException() on every request.
-    await tokenization_1.initializeTokenizers.catch(() => { });
-    try {
-        contextProviderBridge.schedule(completionState, id, options?.opportunityId ?? '', telemetryData, token, options);
-        notifierService.notifyRequest(completionState, id, telemetryData, token, options);
-        const result = await instantiationService.invokeFunction(getGhostTextWithoutAbortHandling, completionState, id, telemetryData, token, options);
-        const statistics = contextproviderStatistics.getStatisticsForCompletion(id);
-        const opportunityId = options?.opportunityId ?? 'unknown';
-        for (const [providerId, statistic] of statistics.getAllUsageStatistics()) {
-            /* __GDPR__
-                "context-provider.completion-stats" : {
-                    "owner": "dirkb",
-                    "comment": "Telemetry for copilot inline completion context",
-                    "requestId": { "classification": "SystemMetaData", "purpose": "FeatureInsight", "comment": "The request correlation id" },
-                    "opportunityId": { "classification": "SystemMetaData", "purpose": "FeatureInsight", "comment": "The opportunity id" },
-                    "providerId": { "classification": "SystemMetaData", "purpose": "FeatureInsight", "comment": "The context provider id" },
-                    "resolution": { "classification": "SystemMetaData", "purpose": "FeatureInsight", "comment": "The resolution of the context" },
-                    "usage": { "classification": "SystemMetaData", "purpose": "FeatureInsight", "comment": "How the context was used" },
-                    "usageDetails": { "classification": "SystemMetaData", "purpose": "FeatureInsight", "comment": "Additional details about the usage as a JSON string" }
-                }
-            */
-            telemetryService.sendMSFTTelemetryEvent('context-provider.completion-stats', {
-                requestId: id,
-                opportunityId,
-                providerId,
-                resolution: statistic.resolution,
-                usage: statistic.usage,
-                usageDetails: JSON.stringify(statistic.usageDetails),
-            }, {});
-        }
-        return result;
-    }
-    catch (e) {
-        // The cancellation token may be called after the request is done but while we still process data.
-        // The underlying implementation catches abort errors for specific scenarios but we still have uncovered paths.
-        // To avoid returning an error to the editor, this acts as an fault barrier here.
-        if ((0, networking_1.isAbortError)(e)) {
+            if (!ghostTextOptions.isSpeculative) {
+                // Update the current ghost text with the new response before returning for the "typing as suggested" UX
+                this.currentGhostText.setGhostText(prefix, prompt.prompt.suffix, postProcessedChoicesArray, resultType);
+            }
+            recordPerformance('complete');
             return {
-                type: 'canceled',
-                reason: 'aborted at unknown location',
-                telemetryData: (0, telemetry_3.mkCanceledResultTelemetry)(telemetryData, {
-                    cancelledNetworkRequest: true,
-                }),
+                type: 'success',
+                value: [results, resultType],
+                telemetryData: (0, telemetry_3.mkBasicResultTelemetry)(telemetryData),
+                telemetryBlob: telemetryData,
+                resultType,
+                performanceMetrics,
             };
-        }
-        throw e;
+        });
     }
+};
+exports.GhostTextComputer = GhostTextComputer;
+exports.GhostTextComputer = GhostTextComputer = __decorate([
+    __param(0, instantiation_1.IInstantiationService),
+    __param(1, telemetry_1.ITelemetryService),
+    __param(2, completionNotifier_1.ICompletionsNotifierService),
+    __param(3, contextProviderBridge_1.ICompletionsContextProviderBridgeService),
+    __param(4, current_1.ICompletionsCurrentGhostText),
+    __param(5, contextProviderStatistics_1.ICompletionsContextProviderService),
+    __param(6, asyncCompletions_1.ICompletionsAsyncManagerService),
+    __param(7, featuresService_1.ICompletionsFeaturesService),
+    __param(8, logger_1.ICompletionsLogTargetService),
+    __param(9, progress_1.ICompletionsStatusReporter),
+    __param(10, logService_1.ILogService)
+], GhostTextComputer);
+async function getGhostText(accessor, completionState, token, options) {
+    const instaService = accessor.get(instantiation_1.IInstantiationService);
+    const ghostTextComputer = instaService.createInstance(GhostTextComputer);
+    return ghostTextComputer.getGhostText(completionState, token, options);
 }
 /**
  * Attempt to get InlineSuggestion locally, in one of two ways:
@@ -828,10 +464,10 @@ function getLocalInlineSuggestion(accessor, prefix, prompt, requestMultiline) {
         // are first so that the shown completion doesn't disappear.
         // Filter duplicates by completionText
         const choicesCacheDeduped = (choicesCache ?? []).filter(c => !choicesTyping.some(t => t.completionText === c.completionText));
-        return [choicesTyping.concat(choicesCacheDeduped), ResultType.TypingAsSuggested];
+        return [choicesTyping.concat(choicesCacheDeduped), resultType_1.ResultType.TypingAsSuggested];
     }
     if (choicesCache && choicesCache.length > 0) {
-        return [choicesCache, ResultType.Cache];
+        return [choicesCache, resultType_1.ResultType.Cache];
     }
 }
 /** Checks if the position is valid inline suggestion position. Returns `undefined` if it's position where ghost text shouldn't be displayed */
@@ -860,12 +496,6 @@ function isValidMiddleOfTheLinePosition(selectionPosition, doc) {
     const endOfLine = line.text.substr(selectionPosition.character).trim();
     return /^\s*[)>}\]"'`]*\s*[:{;,]?\s*$/.test(endOfLine);
 }
-/** Checks if position is the beginning of an empty line (including indentation) */
-function isNewLine(selectionPosition, doc) {
-    const line = doc.lineAt(selectionPosition);
-    const lineTrimmed = line.text.trim();
-    return lineTrimmed.length === 0;
-}
 // This enables tests to control multi line behavior
 class ForceMultiLine {
     static { this.default = new ForceMultiLine(); }
@@ -874,60 +504,6 @@ class ForceMultiLine {
     }
 }
 exports.ForceMultiLine = ForceMultiLine;
-async function shouldRequestMultiline(accessor, blockMode, document, position, inlineSuggestion, afterAccept, prompt) {
-    // Parsing long files for multiline completions is slow, so we only do
-    // it for files with less than 8000 lines
-    if (document.lineCount >= 8000) {
-        (0, telemetry_2.telemetry)(accessor, 'ghostText.longFileMultilineSkip', telemetry_2.TelemetryData.createAndMarkAsIssued({
-            languageId: document.detectedLanguageId,
-            lineCount: String(document.lineCount),
-            currentLine: String(position.line),
-        }));
-    }
-    else {
-        if (blockMode === config_1.BlockMode.MoreMultiline && blockTrimmer_1.BlockTrimmer.isSupported(document.detectedLanguageId)) {
-            if (!afterAccept) {
-                return { requestMultiline: false };
-            }
-            const blockPosition = await (0, blockTrimmer_1.getBlockPositionType)(document, position);
-            return { requestMultiline: true, blockPosition };
-        }
-        const targetLanguagesNewLine = ['typescript', 'typescriptreact'];
-        if (targetLanguagesNewLine.includes(document.detectedLanguageId)) {
-            const newLine = isNewLine(position, document);
-            if (newLine) {
-                return { requestMultiline: true };
-            }
-        }
-        let requestMultiline = false;
-        if (!inlineSuggestion && (0, parse_1.isSupportedLanguageId)(document.detectedLanguageId)) {
-            // Can only check block-level nodes of languages we support
-            requestMultiline = await (0, parseBlock_1.isEmptyBlockStartUtil)(document, position);
-        }
-        else if (inlineSuggestion && (0, parse_1.isSupportedLanguageId)(document.detectedLanguageId)) {
-            //If we are inline, check if we would suggest multiline for current position or if we would suggest a multiline completion if we were at the end of the line
-            requestMultiline =
-                (await (0, parseBlock_1.isEmptyBlockStartUtil)(document, position)) ||
-                    (await (0, parseBlock_1.isEmptyBlockStartUtil)(document, document.lineAt(position).range.end));
-        }
-        // If requestMultiline is false, for specific languages check multiline score
-        if (!requestMultiline) {
-            const requestMultiModelThreshold = 0.5;
-            const targetLanguagesModel = ['javascript', 'javascriptreact', 'python'];
-            if (targetLanguagesModel.includes(document.detectedLanguageId)) {
-                // Call multiline model if not multiline and EXP flag is set.
-                const multiModelScore = (0, multilineModel_1.requestMultilineScore)(prompt.prompt, document.detectedLanguageId);
-                requestMultiline = multiModelScore > requestMultiModelThreshold;
-            }
-        }
-        return { requestMultiline };
-    }
-    return { requestMultiline: false };
-}
-/** Appends completions to existing entry in cache or creates new entry. */
-function appendToCache(accessor, requestContext, choice) {
-    accessor.get(completionsCache_1.ICompletionsCacheService).append(requestContext.prefix, requestContext.prompt.suffix, choice);
-}
 function adjustLeadingWhitespace(index, text, ws) {
     if (ws.length > 0) {
         if (text.startsWith(ws)) {
@@ -975,14 +551,14 @@ function adjustLeadingWhitespace(index, text, ws) {
  * remaining current prefix.
  */
 function getCompletionsFromCache(accessor, prefix, suffix, multiline) {
-    const logTarget = accessor.get(logger_1.ICompletionsLogTargetService);
+    const logger = accessor.get(logService_1.ILogService).createSubLogger(['ghostText', 'getCompletionsFromCache']);
     const choices = accessor.get(completionsCache_1.ICompletionsCacheService).findAll(prefix, suffix);
     if (choices.length === 0) {
-        ghostTextLogger.debug(logTarget, `Found no completions in cache`);
+        logger.debug('Found no completions in cache');
         return [];
     }
-    ghostTextLogger.debug(logTarget, `Found ${choices.length} completions in cache`);
-    return choices.map(choice => makeGhostAPIChoice(choice, { forceSingleLine: !multiline }));
+    logger.debug(`Found ${choices.length} completions in cache`);
+    return choices.map(choice => (0, completionsFromNetwork_1.makeGhostAPIChoice)(choice, { forceSingleLine: !multiline }));
 }
 /** Create a TelemetryWithExp instance for a ghost text request. */
 async function createTelemetryWithExp(accessor, document, headerRequestId, options) {
@@ -1100,19 +676,4 @@ function addDocumentTelemetry(telemetry, document) {
     telemetry.measurements.documentLength = document.getText().length;
     telemetry.measurements.documentLineCount = document.lineCount;
 }
-function telemetryPerformance(accessor, performanceKind, choice, requestStart, processingTimeMs) {
-    const requestTimeMs = Date.now() - requestStart;
-    const deltaMs = requestTimeMs - processingTimeMs;
-    const telemetryData = choice.telemetryData.extendedBy({}, {
-        completionCharLen: choice.completionText.length,
-        requestTimeMs: requestTimeMs,
-        processingTimeMs: processingTimeMs,
-        deltaMs: deltaMs,
-        // Choice properties
-        meanLogProb: choice.meanLogProb || NaN,
-        meanAlternativeLogProb: choice.meanAlternativeLogProb || NaN,
-    });
-    telemetryData.extendWithRequestId(choice.requestId);
-    (0, telemetry_2.telemetry)(accessor, `ghostText.${performanceKind}`, telemetryData);
-}
 //# sourceMappingURL=ghostText.js.map