@vscode/chat-lib 0.1.2 → 0.1.3-1

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

@@ -0,0 +1,1118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ForceMultiLine = exports.ResultType = 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 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");
+const parseBlock_1 = require("../prompt/parseBlock");
+const prompt_1 = require("../prompt/prompt");
+const repository_1 = require("../prompt/repository");
+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 current_1 = require("./current");
+const multilineModel_1 = require("./multilineModel");
+const streamedCompletionSplitter_1 = require("./streamedCompletionSplitter");
+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 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 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),
+            };
+        }
+        if (res.type === 'canceled') {
+            ghostTextLogger.debug(logTarget, 'Cancelled after awaiting fetchCompletions');
+            return {
+                type: 'canceled',
+                reason: res.reason,
+                telemetryData: (0, telemetry_3.mkCanceledResultTelemetry)(baseTelemetryData),
+            };
+        }
+        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)) {
+            return {
+                type: 'canceled',
+                reason: 'network request aborted',
+                telemetryData: (0, telemetry_3.mkCanceledResultTelemetry)(baseTelemetryData, {
+                    cancelledNetworkRequest: true,
+                }),
+            };
+        }
+        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
+            return {
+                type: 'failed',
+                reason: 'non-abort error on ghost text request',
+                telemetryData: (0, telemetry_3.mkBasicResultTelemetry)(baseTelemetryData),
+            };
+        }
+    }
+}
+/**
+ * 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');
+            return {
+                type: 'empty',
+                reason: 'all choices redacted',
+                telemetryData: (0, telemetry_3.mkBasicResultTelemetry)(baseTelemetryData),
+            };
+        }
+        if (cancellationToken?.isCancellationRequested) {
+            ghostTextLogger.debug(logTarget, 'Cancelled after awaiting redactedChoices iterator');
+            return {
+                type: 'canceled',
+                reason: 'after awaiting redactedChoices iterator',
+                telemetryData: (0, telemetry_3.mkCanceledResultTelemetry)(baseTelemetryData),
+            };
+        }
+        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');
+            return {
+                type: 'empty',
+                reason: 'got undefined choice from redactedChoices iterator',
+                telemetryData: (0, telemetry_3.mkBasicResultTelemetry)(baseTelemetryData),
+            };
+        }
+        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)}`);
+        }
+        //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 (processedFirstChoice) {
+            // Because we ask the server to stop at \n above, we don't need to force single line here
+            return {
+                type: 'success',
+                value: [makeGhostAPIChoice(processedFirstChoice, { forceSingleLine: false }), cacheDone],
+                telemetryData: (0, telemetry_3.mkBasicResultTelemetry)(baseTelemetryData),
+                telemetryBlob: baseTelemetryData,
+                resultType: ResultType.Network,
+            };
+        }
+        else {
+            return {
+                type: 'empty',
+                reason: 'got undefined processedFirstChoice',
+                telemetryData: (0, telemetry_3.mkBasicResultTelemetry)(baseTelemetryData),
+            };
+        }
+    });
+}
+/** 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');
+                return {
+                    type: 'canceled',
+                    reason: 'after awaiting choices iterator',
+                    telemetryData: (0, telemetry_3.mkCanceledResultTelemetry)(baseTelemetryData),
+                };
+            }
+            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,
+            };
+        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;
+                }
+                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;
+                }
+                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];
+            }
+            if (inlineCompletionRequestCancelled(currentGhostText, ourRequestId, cancellationToken)) {
+                ghostTextLogger.debug(logTarget, 'Cancelled before requesting a new completion');
+                return {
+                    type: 'abortedBeforeIssued',
+                    reason: 'Cancelled after waiting for async completion',
+                    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;
+                        }
+                        resultChoices.push(c);
+                    });
+                    choices = [resultChoices, ResultType.Cycling];
+                }
+                else {
+                    if (choices === undefined) {
+                        return networkChoices;
+                    }
+                }
+            }
+            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);
+                };
+                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) {
+                    return {
+                        type: 'empty',
+                        reason: 'received no results from async completions',
+                        telemetryData: (0, telemetry_3.mkBasicResultTelemetry)(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');
+                return {
+                    type: 'canceled',
+                    reason: 'after completions delay',
+                    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)) {
+            return {
+                type: 'canceled',
+                reason: 'aborted at unknown location',
+                telemetryData: (0, telemetry_3.mkCanceledResultTelemetry)(telemetryData, {
+                    cancelledNetworkRequest: true,
+                }),
+            };
+        }
+        throw e;
+    }
+}
+/**
+ * Attempt to get InlineSuggestion locally, in one of two ways:
+ *  1. If the user is typing the letters already displayed as inline suggestion.
+ *  2. If we have a previously cached inline suggestion for this prompt and requestMultiline.
+ */
+function getLocalInlineSuggestion(accessor, prefix, prompt, requestMultiline) {
+    const currentGhostText = accessor.get(current_1.ICompletionsCurrentGhostText);
+    const choicesTyping = currentGhostText.getCompletionsForUserTyping(prefix, prompt.suffix);
+    const choicesCache = getCompletionsFromCache(accessor, prefix, prompt.suffix, requestMultiline);
+    if (choicesTyping && choicesTyping.length > 0) {
+        // Append cached choices to choicesTyping, if any. Ensure typing choices
+        // 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];
+    }
+    if (choicesCache && choicesCache.length > 0) {
+        return [choicesCache, ResultType.Cache];
+    }
+}
+/** Checks if the position is valid inline suggestion position. Returns `undefined` if it's position where ghost text shouldn't be displayed */
+function isInlineSuggestion(document, position) {
+    //Checks if we're in the position for the middle of the line suggestion
+    const isMiddleOfLine = isMiddleOfTheLine(position, document);
+    const isValidMiddleOfLine = isValidMiddleOfTheLinePosition(position, document);
+    if (isMiddleOfLine && !isValidMiddleOfLine) {
+        return;
+    }
+    const isInlineSuggestion = isMiddleOfLine && isValidMiddleOfLine;
+    return isInlineSuggestion;
+}
+/** Checks if position is NOT at the end of the line */
+function isMiddleOfTheLine(selectionPosition, doc) {
+    // must be end of line or trailing whitespace
+    const line = doc.lineAt(selectionPosition);
+    if (line.text.substr(selectionPosition.character).trim().length !== 0) {
+        return true;
+    }
+    return false;
+}
+/** Checks if position is valid for the middle of the line suggestion */
+function isValidMiddleOfTheLinePosition(selectionPosition, doc) {
+    const line = doc.lineAt(selectionPosition);
+    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(); }
+    constructor(requestMultilineOverride = false) {
+        this.requestMultilineOverride = requestMultilineOverride;
+    }
+}
+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)) {
+            // Remove common prefix so that it can display in the correct position
+            return {
+                completionIndex: index,
+                completionText: text,
+                displayText: text.substring(ws.length),
+                displayNeedsWsOffset: false,
+            };
+        }
+        else {
+            // The idea here is that we do want the display to be as close to the final position as possible
+            const textLeftWs = text.substring(0, text.length - text.trimStart().length);
+            if (ws.startsWith(textLeftWs)) {
+                // NOTE: It's possible that `ws` is a bit too over-indented. Example:
+                // def foo(n):
+                //     if n > 0:
+                //         print(f"n is positive: {n}")
+                //         [cursor is here after new line]
+                //
+                // completion: "    else:"
+                return {
+                    completionIndex: index,
+                    completionText: text,
+                    displayText: text.trimStart(),
+                    displayNeedsWsOffset: true,
+                };
+            }
+            else {
+                // We don't know any better so just send `text` back
+                return { completionIndex: index, completionText: text, displayText: text, displayNeedsWsOffset: false };
+            }
+        }
+    }
+    else {
+        // If we do not know leading whitespace or if it is an empty string, just return input text
+        return { completionIndex: index, completionText: text, displayText: text, displayNeedsWsOffset: false };
+    }
+}
+/**
+ * Returns all completions from the cache for given document prefix. Walks back
+ * from the current prefix to search for completions with a prefix that
+ * partially matches the current prefix and completion text that matches the
+ * remaining current prefix.
+ */
+function getCompletionsFromCache(accessor, prefix, suffix, multiline) {
+    const logTarget = accessor.get(logger_1.ICompletionsLogTargetService);
+    const choices = accessor.get(completionsCache_1.ICompletionsCacheService).findAll(prefix, suffix);
+    if (choices.length === 0) {
+        ghostTextLogger.debug(logTarget, `Found no completions in cache`);
+        return [];
+    }
+    ghostTextLogger.debug(logTarget, `Found ${choices.length} completions in cache`);
+    return choices.map(choice => makeGhostAPIChoice(choice, { forceSingleLine: !multiline }));
+}
+/** Create a TelemetryWithExp instance for a ghost text request. */
+async function createTelemetryWithExp(accessor, document, headerRequestId, options) {
+    const featuresService = accessor.get(featuresService_1.ICompletionsFeaturesService);
+    const properties = { headerRequestId };
+    if (options?.opportunityId) {
+        properties.opportunityId = options.opportunityId;
+    }
+    if (options?.selectedCompletionInfo?.text) {
+        properties.completionsActive = 'true';
+    }
+    if (options?.isSpeculative) {
+        properties.reason = 'speculative';
+    }
+    const telemetryData = telemetry_2.TelemetryData.createAndMarkAsIssued(properties);
+    const telemetryWithExp = await featuresService.updateExPValuesAndAssignments({ uri: document.uri, languageId: document.detectedLanguageId }, telemetryData);
+    return telemetryWithExp;
+}
+/** Return a copy of the choice's telemetry data with extra information added */
+function telemetryWithAddData(document, requestContext, choice, issuedTelemetryData) {
+    const requestId = choice.requestId;
+    const properties = {
+        choiceIndex: choice.choiceIndex.toString(),
+        clientCompletionId: choice.clientCompletionId,
+    };
+    if (choice.generatedChoiceIndex !== undefined) {
+        properties.originalChoiceIndex = properties.choiceIndex;
+        properties.choiceIndex = (10_000 * (choice.generatedChoiceIndex + 1) + choice.choiceIndex).toString();
+    }
+    const measurements = {
+        compCharLen: choice.completionText.length,
+        numLines: choice.completionText.trim().split('\n').length,
+    };
+    // Add assessments
+    if (choice.meanLogProb) {
+        measurements.meanLogProb = choice.meanLogProb;
+    }
+    if (choice.meanAlternativeLogProb) {
+        measurements.meanAlternativeLogProb = choice.meanAlternativeLogProb;
+    }
+    const extendedTelemetry = choice.telemetryData.extendedBy(properties, measurements);
+    extendedTelemetry.issuedTime = issuedTelemetryData.issuedTime;
+    extendedTelemetry.measurements.timeToProduceMs = performance.now() - issuedTelemetryData.issuedTime;
+    addDocumentTelemetry(extendedTelemetry, document);
+    extendedTelemetry.extendWithRequestId(requestId);
+    return extendedTelemetry;
+}
+/** Create new telemetry data based on baseTelemetryData and send `ghostText.issued` event  */
+function telemetryIssued(accessor, document, requestContext, position, prompt, baseTelemetryData, requestInfo, ghostTextOptions) {
+    // base ghostText telemetry data
+    const properties = {
+        languageId: document.detectedLanguageId,
+    };
+    properties.afterAccept = requestContext.afterAccept.toString();
+    properties.isSpeculative = ghostTextOptions.isSpeculative.toString();
+    const telemetryData = baseTelemetryData.extendedBy(properties);
+    addDocumentTelemetry(telemetryData, document);
+    // Add repository information
+    const repoInfo = requestContext.repoInfo;
+    telemetryData.properties.gitRepoInformation =
+        repoInfo === undefined ? 'unavailable' : repoInfo === repository_1.ComputationStatus.PENDING ? 'pending' : 'available';
+    if (repoInfo !== undefined && repoInfo !== repository_1.ComputationStatus.PENDING) {
+        telemetryData.properties.gitRepoUrl = repoInfo.url;
+        telemetryData.properties.gitRepoHost = repoInfo.hostname;
+        if (repoInfo.repoId?.type === 'github') {
+            telemetryData.properties.gitRepoOwner = repoInfo.repoId.org;
+            telemetryData.properties.gitRepoName = repoInfo.repoId.repo;
+        }
+        else if (repoInfo.repoId?.type === 'ado') {
+            telemetryData.properties.gitRepoOwner = repoInfo.repoId.project;
+            telemetryData.properties.gitRepoName = repoInfo.repoId.repo;
+        }
+        else {
+            // TODO: We don't have generic owner and repo for other providers
+        }
+        telemetryData.properties.gitRepoPath = repoInfo.pathname;
+    }
+    telemetryData.properties.engineName = requestInfo.modelId;
+    telemetryData.properties.engineChoiceSource = requestInfo.engineChoiceSource;
+    // Add requestMultiline information
+    telemetryData.properties.isMultiline = JSON.stringify(requestContext.multiline);
+    telemetryData.properties.isCycling = JSON.stringify(requestContext.isCycling);
+    // calculated values for the issued event
+    const currentLine = document.lineAt(position.line);
+    const lineBeforeCursor = document.getText(textDocument_1.LocationFactory.range(currentLine.range.start, position));
+    const restOfLine = document.getText(textDocument_1.LocationFactory.range(position, currentLine.range.end));
+    const typeFileHashCode = Array.from(prompt.neighborSource.entries()).map(typeFiles => [
+        typeFiles[0],
+        typeFiles[1].map(f => (0, crypto_1.createSha256Hash)(f).toString()), // file name is sensitive. We just keep SHA256 of the file name.
+    ]);
+    // Properties that we only want to include in the issued event
+    const extendedProperties = {
+        beforeCursorWhitespace: JSON.stringify(lineBeforeCursor.trim() === ''),
+        afterCursorWhitespace: JSON.stringify(restOfLine.trim() === ''),
+        neighborSource: JSON.stringify(typeFileHashCode),
+        blockMode: requestContext.blockMode,
+    };
+    const extendedMeasurements = {
+        ...(0, telemetry_2.telemetrizePromptLength)(prompt.prompt),
+        promptEndPos: document.offsetAt(position),
+        promptComputeTimeMs: prompt.computeTimeMs,
+    };
+    if (prompt.metadata) {
+        extendedProperties.promptMetadata = JSON.stringify(prompt.metadata);
+    }
+    if (prompt.contextProvidersTelemetry) {
+        extendedProperties.contextProviders = JSON.stringify(prompt.contextProvidersTelemetry);
+    }
+    const telemetryDataToSend = telemetryData.extendedBy(extendedProperties, extendedMeasurements);
+    // telemetrize the issued event
+    (0, telemetry_2.telemetry)(accessor, 'ghostText.issued', telemetryDataToSend);
+    return telemetryData;
+}
+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