@vscode/chat-lib 0.1.2-0 → 0.1.2

package/dist/src/_internal/extension/prompt/node/chatMLFetcher.js

@@ -47,41 +47,30 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ChatMLFetcherImpl = exports.AbstractChatMLFetcher = void 0;
-exports.createTelemetryData = createTelemetryData;
-exports.locationToIntent = locationToIntent;
 const prompt_tsx_1 = require("@vscode/prompt-tsx");
-const authentication_1 = require("../../../platform/authentication/common/authentication");
 const chatMLFetcher_1 = require("../../../platform/chat/common/chatMLFetcher");
-const chatQuotaService_1 = require("../../../platform/chat/common/chatQuotaService");
 const commonTypes_1 = require("../../../platform/chat/common/commonTypes");
 const conversationOptions_1 = require("../../../platform/chat/common/conversationOptions");
 const globalStringUtils_1 = require("../../../platform/chat/common/globalStringUtils");
-const interactionService_1 = require("../../../platform/chat/common/interactionService");
 const configurationService_1 = require("../../../platform/configuration/common/configurationService");
-const capiClient_1 = require("../../../platform/endpoint/common/capiClient");
 const autoChatEndpoint_1 = require("../../../platform/endpoint/node/autoChatEndpoint");
 const logService_1 = require("../../../platform/log/common/logService");
-const fetch_1 = require("../../../platform/networking/common/fetch");
 const fetcherService_1 = require("../../../platform/networking/common/fetcherService");
-const networking_1 = require("../../../platform/networking/common/networking");
 const openai_1 = require("../../../platform/networking/common/openai");
-const chatStream_1 = require("../../../platform/networking/node/chatStream");
-const stream_1 = require("../../../platform/networking/node/stream");
-const fetch_2 = require("../../../platform/openai/node/fetch");
+const fetch_1 = require("../../../platform/openai/node/fetch");
 const requestLogger_1 = require("../../../platform/requestLogger/node/requestLogger");
-const nullExperimentationService_1 = require("../../../platform/telemetry/common/nullExperimentationService");
 const telemetry_1 = require("../../../platform/telemetry/common/telemetry");
 const telemetryData_1 = require("../../../platform/telemetry/common/telemetryData");
 const anomalyDetection_1 = require("../../../util/common/anomalyDetection");
-const crypto_1 = require("../../../util/common/crypto");
 const errorsUtil = __importStar(require("../../../util/common/errors"));
 const errors_1 = require("../../../util/vs/base/common/errors");
 const event_1 = require("../../../util/vs/base/common/event");
-const strings_1 = require("../../../util/vs/base/common/strings");
 const uuid_1 = require("../../../util/vs/base/common/uuid");
+const instantiation_1 = require("../../../util/vs/platform/instantiation/common/instantiation");
 const openAIEndpoint_1 = require("../../byok/node/openAIEndpoint");
 const constants_1 = require("../../common/constants");
-const chatMLFetcherTelemetry_1 = require("./chatMLFetcherTelemetry");
+const authentication_1 = require("../../../platform/authentication/common/authentication");
+const strings_1 = require("../../../util/vs/base/common/strings");
 class AbstractChatMLFetcher {
     constructor(options) {
         this.options = options;
@@ -110,18 +99,14 @@ class AbstractChatMLFetcher {
 }
 exports.AbstractChatMLFetcher = AbstractChatMLFetcher;
 let ChatMLFetcherImpl = class ChatMLFetcherImpl extends AbstractChatMLFetcher {
-    constructor(_fetcherService, _telemetryService, _requestLogger, _logService, _authenticationService, _interactionService, _chatQuotaService, _capiClientService, options, _configurationService, _experimentationService) {
+    constructor(_fetcherService, _telemetryService, _requestLogger, _logService, _authenticationService, _instantiationService, options) {
         super(options);
         this._fetcherService = _fetcherService;
         this._telemetryService = _telemetryService;
         this._requestLogger = _requestLogger;
         this._logService = _logService;
         this._authenticationService = _authenticationService;
-        this._interactionService = _interactionService;
-        this._chatQuotaService = _chatQuotaService;
-        this._capiClientService = _capiClientService;
-        this._configurationService = _configurationService;
-        this._experimentationService = _experimentationService;
+        this._instantiationService = _instantiationService;
     }
     /**
      * Note: the returned array of strings may be less than `n` (e.g., in case there were errors during streaming)
@@ -145,7 +130,7 @@ let ChatMLFetcherImpl = class ChatMLFetcherImpl extends AbstractChatMLFetcher {
             delete requestOptions['prediction'];
         }
         const postOptions = this.preparePostOptions(requestOptions);
-        const requestBody = chatEndpoint.createRequestBody({
+        const requestBody = await chatEndpoint.createRequestBody({
             ...opts,
             requestId: ourRequestId,
             postOptions
@@ -166,22 +151,19 @@ let ChatMLFetcherImpl = class ChatMLFetcherImpl extends AbstractChatMLFetcher {
         let tokenCount = -1;
         const streamRecorder = new chatMLFetcher_1.FetchStreamRecorder(finishedCb);
         const enableRetryOnError = opts.enableRetryOnError ?? opts.enableRetryOnFilter;
-        let usernameToScrub;
         try {
             let response;
             const payloadValidationResult = isValidChatPayload(opts.messages, postOptions);
             if (!payloadValidationResult.isValid) {
                 response = {
-                    type: fetch_2.FetchResponseKind.Failed,
+                    type: fetch_1.FetchResponseKind.Failed,
                     modelRequestId: undefined,
-                    failKind: fetch_2.ChatFailKind.ValidationFailed,
+                    failKind: fetch_1.ChatFailKind.ValidationFailed,
                     reason: payloadValidationResult.reason,
                 };
             }
             else {
-                const copilotToken = await this._authenticationService.getCopilotToken();
-                usernameToScrub = copilotToken.username;
-                response = await this._fetchAndStreamChat(chatEndpoint, requestBody, baseTelemetry, streamRecorder.callback, requestOptions.secretKey, copilotToken, opts.location, ourRequestId, postOptions.n, token, userInitiatedRequest, telemetryProperties, opts.useFetcher);
+                response = await this._instantiationService.invokeFunction(accessor => (0, fetch_1.fetchAndStreamChat)(accessor, chatEndpoint, requestBody, baseTelemetry, streamRecorder.callback, requestOptions.secretKey, opts.location, ourRequestId, postOptions.n, userInitiatedRequest, token, telemetryProperties, opts.useFetcher));
                 tokenCount = await chatEndpoint.acquireTokenizer().countMessagesTokens(messages);
                 const extensionId = source?.extensionId ?? constants_1.EXTENSION_ID;
                 this._onDidMakeChatMLRequest.fire({
@@ -194,7 +176,7 @@ let ChatMLFetcherImpl = class ChatMLFetcherImpl extends AbstractChatMLFetcher {
             const timeToFirstToken = Date.now() - baseTelemetry.issuedTime;
             pendingLoggedChatRequest?.markTimeToFirstToken(timeToFirstToken);
             switch (response.type) {
-                case fetch_2.FetchResponseKind.Success: {
+                case fetch_1.FetchResponseKind.Success: {
                     const result = await this.processSuccessfulResponse(response, messages, requestBody, ourRequestId, maxResponseTokens, tokenCount, timeToFirstToken, streamRecorder, baseTelemetry, chatEndpoint, userInitiatedRequest);
                     // Handle FilteredRetry case with augmented messages
                     if (result.type === commonTypes_1.ChatFetchResponseType.FilteredRetry) {
@@ -244,17 +226,15 @@ let ChatMLFetcherImpl = class ChatMLFetcherImpl extends AbstractChatMLFetcher {
                     pendingLoggedChatRequest?.resolve(result, streamRecorder.deltas);
                     return result;
                 }
-                case fetch_2.FetchResponseKind.Canceled:
-                    chatMLFetcherTelemetry_1.ChatMLFetcherTelemetrySender.sendCancellationTelemetry(this._telemetryService, {
+                case fetch_1.FetchResponseKind.Canceled:
+                    this._sendCancellationTelemetry({
                         source: telemetryProperties.messageSource ?? 'unknown',
                         requestId: ourRequestId,
                         model: chatEndpoint.model,
                         apiType: chatEndpoint.apiType,
                         associatedRequestId: telemetryProperties.associatedRequestId,
-                        retryAfterErrorCategory: telemetryProperties.retryAfterErrorCategory,
-                        retryAfterError: telemetryProperties.retryAfterError,
-                        connectivityTestError: telemetryProperties.connectivityTestError,
-                        retryAfterFilterCategory: telemetryProperties.retryAfterFilterCategory,
+                        ...(telemetryProperties.retryAfterErrorCategory ? { retryAfterErrorCategory: telemetryProperties.retryAfterErrorCategory } : {}),
+                        ...(telemetryProperties.retryAfterFilterCategory ? { retryAfterFilterCategory: telemetryProperties.retryAfterFilterCategory } : {}),
                     }, {
                         totalTokenMax: chatEndpoint.modelMaxPromptTokens ?? -1,
                         promptTokenCount: tokenCount,
@@ -268,9 +248,9 @@ let ChatMLFetcherImpl = class ChatMLFetcherImpl extends AbstractChatMLFetcher {
                     });
                     pendingLoggedChatRequest?.resolveWithCancelation();
                     return this.processCanceledResponse(response, ourRequestId);
-                case fetch_2.FetchResponseKind.Failed: {
+                case fetch_1.FetchResponseKind.Failed: {
                     const processed = this.processFailedResponse(response, ourRequestId);
-                    chatMLFetcherTelemetry_1.ChatMLFetcherTelemetrySender.sendResponseErrorTelemetry(this._telemetryService, processed, telemetryProperties, chatEndpoint, requestBody, tokenCount, maxResponseTokens, timeToFirstToken, this.filterImageMessages(messages));
+                    this._sendResponseErrorTelemetry(processed, telemetryProperties, ourRequestId, chatEndpoint, requestBody, tokenCount, maxResponseTokens, timeToFirstToken, this.filterImageMessages(messages));
                     pendingLoggedChatRequest?.resolve(processed);
                     return processed;
                 }
@@ -278,59 +258,38 @@ let ChatMLFetcherImpl = class ChatMLFetcherImpl extends AbstractChatMLFetcher {
         }
         catch (err) {
             const timeToError = Date.now() - baseTelemetry.issuedTime;
-            const processed = this.processError(err, ourRequestId, usernameToScrub);
-            let connectivityTestError = telemetryProperties.connectivityTestError;
-            if (processed.type === commonTypes_1.ChatFetchResponseType.NetworkError && enableRetryOnError) {
-                // Keep existing handling of net::ERR_NETWORK_CHANGED: https://github.com/microsoft/vscode/issues/260297
-                const isNetworkChangedError = ['darwin', 'linux'].includes(process.platform) && processed.reason.indexOf('net::ERR_NETWORK_CHANGED') !== -1;
-                const isRetryNetworkErrorEnabled = this._configurationService.getExperimentBasedConfig(configurationService_1.ConfigKey.TeamInternal.RetryNetworkErrors, this._experimentationService);
-                if (isNetworkChangedError || isRetryNetworkErrorEnabled) {
-                    const useFetcher = isNetworkChangedError ? 'node-fetch' : opts.useFetcher;
-                    this._logService.info(`Retrying chat request with ${useFetcher || 'default'} fetcher after: ${processed.reasonDetail || processed.reason}`);
-                    // Keep existing handling of net::ERR_NETWORK_CHANGED if setting is not enabled: https://github.com/microsoft/vscode/issues/260297
-                    const connectivity = !isRetryNetworkErrorEnabled ? { retryRequest: true } : await this._checkNetworkConnectivity(useFetcher);
-                    connectivityTestError = connectivity.connectivityTestError ? this.scrubErrorDetail(connectivity.connectivityTestError, usernameToScrub) : undefined;
-                    if (connectivity.retryRequest) {
-                        streamRecorder.callback('', 0, { text: '', retryReason: 'network_error' });
-                        const retryResult = await this.fetchMany({
-                            ...opts,
-                            debugName: 'retry-error-' + debugName,
-                            messages,
-                            finishedCb,
-                            location,
-                            endpoint: chatEndpoint,
-                            source,
-                            requestOptions,
-                            userInitiatedRequest: false, // do not mark the retry as user initiated
-                            telemetryProperties: {
-                                ...telemetryProperties,
-                                retryAfterErrorCategory: processed.reasonDetail || processed.reason,
-                                retryAfterError: processed.reasonDetail || processed.reason,
-                                connectivityTestError,
-                            },
-                            enableRetryOnFilter: opts.enableRetryOnFilter,
-                            enableRetryOnError: false,
-                            useFetcher,
-                        }, token);
-                        pendingLoggedChatRequest?.resolve(retryResult, streamRecorder.deltas);
-                        return retryResult;
-                    }
-                    else {
-                        this._logService.info(`Not retrying chat request as network connectivity could not be re-established.`);
-                    }
+            const processed = this.processError(err, ourRequestId);
+            if (['darwin', 'linux'].includes(process.platform) && processed.type === commonTypes_1.ChatFetchResponseType.NetworkError && processed.reason.indexOf('net::ERR_NETWORK_CHANGED') !== -1) {
+                if (enableRetryOnError) {
+                    this._logService.info('Retrying chat request with node-fetch after net::ERR_NETWORK_CHANGED error.');
+                    streamRecorder.callback('', 0, { text: '', retryReason: 'network_error' });
+                    // Retry with other fetchers
+                    const retryResult = await this.fetchMany({
+                        ...opts,
+                        debugName: 'retry-error-' + debugName,
+                        messages,
+                        finishedCb,
+                        location,
+                        endpoint: chatEndpoint,
+                        source,
+                        requestOptions,
+                        userInitiatedRequest: false, // do not mark the retry as user initiated
+                        telemetryProperties: { ...telemetryProperties, retryAfterErrorCategory: 'electron-network-changed' },
+                        enableRetryOnFilter: opts.enableRetryOnFilter,
+                        enableRetryOnError: false,
+                        useFetcher: 'node-fetch',
+                    }, token);
+                    pendingLoggedChatRequest?.resolve(retryResult, streamRecorder.deltas);
+                    return retryResult;
                 }
             }
             if (processed.type === commonTypes_1.ChatFetchResponseType.Canceled) {
-                chatMLFetcherTelemetry_1.ChatMLFetcherTelemetrySender.sendCancellationTelemetry(this._telemetryService, {
+                this._sendCancellationTelemetry({
                     source: telemetryProperties.messageSource ?? 'unknown',
                     requestId: ourRequestId,
                     model: chatEndpoint.model,
                     apiType: chatEndpoint.apiType,
-                    associatedRequestId: telemetryProperties.associatedRequestId,
-                    retryAfterErrorCategory: telemetryProperties.retryAfterErrorCategory,
-                    retryAfterError: telemetryProperties.retryAfterError,
-                    connectivityTestError,
-                    retryAfterFilterCategory: telemetryProperties.retryAfterFilterCategory,
+                    associatedRequestId: telemetryProperties.associatedRequestId
                 }, {
                     totalTokenMax: chatEndpoint.modelMaxPromptTokens ?? -1,
                     promptTokenCount: tokenCount,
@@ -343,407 +302,170 @@ let ChatMLFetcherImpl = class ChatMLFetcherImpl extends AbstractChatMLFetcher {
                 });
             }
             else {
-                chatMLFetcherTelemetry_1.ChatMLFetcherTelemetrySender.sendResponseErrorTelemetry(this._telemetryService, processed, { ...telemetryProperties, connectivityTestError }, chatEndpoint, requestBody, tokenCount, maxResponseTokens, timeToError, this.filterImageMessages(messages));
+                this._sendResponseErrorTelemetry(processed, telemetryProperties, ourRequestId, chatEndpoint, requestBody, tokenCount, maxResponseTokens, timeToError, this.filterImageMessages(messages));
             }
             pendingLoggedChatRequest?.resolve(processed);
             return processed;
         }
     }
-    async _checkNetworkConnectivity(useFetcher) {
-        // Ping CAPI to check network connectivity before retrying
-        const delays = [1000, 10000, 10000];
-        let connectivityTestError = undefined;
-        for (const delay of delays) {
-            this._logService.info(`Waiting ${delay}ms before pinging CAPI to check network connectivity...`);
-            await new Promise(resolve => setTimeout(resolve, delay));
-            try {
-                const isGHEnterprise = this._capiClientService.dotcomAPIURL !== 'https://api.github.com';
-                const url = this._capiClientService.capiPingURL;
-                const headers = await this._getAuthHeaders(isGHEnterprise, url);
-                const res = await this._fetcherService.fetch(url, {
-                    headers,
-                    useFetcher,
-                });
-                if (res.status >= 200 && res.status < 300) {
-                    this._logService.info(`CAPI ping successful, proceeding with chat request retry...`);
-                    return { retryRequest: true, connectivityTestError };
-                }
-                else {
-                    connectivityTestError = `Status ${res.status}: ${res.statusText}`;
-                    this._logService.info(`CAPI ping returned status ${res.status}, retrying ping...`);
-                }
-            }
-            catch (err) {
-                connectivityTestError = (0, logService_1.collectSingleLineErrorMessage)(err);
-                this._logService.info(`CAPI ping failed with error, retrying ping: ${connectivityTestError}`);
-            }
-        }
-        return { retryRequest: false, connectivityTestError };
-    }
-    async _getAuthHeaders(isGHEnterprise, url) {
-        const authHeaders = {};
-        if (isGHEnterprise) {
-            let token = '';
-            if (url === this._capiClientService.dotcomAPIURL) {
-                token = this._authenticationService.anyGitHubSession?.accessToken || '';
+    _sendCancellationTelemetry({ source, requestId, model, apiType, associatedRequestId }, { totalTokenMax, promptTokenCount, tokenCountMax, timeToFirstToken, timeToFirstTokenEmitted, timeToCancelled, isVisionRequest, isBYOK, isAuto }) {
+        /* __GDPR__
+            "response.cancelled" : {
+                "owner": "digitarald",
+                "comment": "Report canceled service responses for quality.",
+                "model": { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth", "comment": "Model selection for the response" },
+                "apiType": { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth", "comment": "API type for the response- chat completions or responses" },
+                "source": { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth", "comment": "Source for why the request was made" },
+                "requestId": { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth", "comment": "Id of the request" },
+                "associatedRequestId": { "classification": "SystemMetaData", "purpose": "FeatureInsight", "comment": "Another request ID that this request is associated with (eg, the originating request of a summarization request)." },
+                "totalTokenMax": { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth", "comment": "Maximum total token window", "isMeasurement": true },
+                "promptTokenCount": { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth", "comment": "Number of prompt tokens", "isMeasurement": true },
+                "tokenCountMax": { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth", "comment": "Maximum generated tokens", "isMeasurement": true },
+                "timeToFirstToken": { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth", "comment": "Time to first token", "isMeasurement": true },
+                "timeToFirstTokenEmitted": { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth", "comment": "Time to first token emitted (visible text)", "isMeasurement": true },
+                "timeToCancelled": { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth", "comment": "Time to first token", "isMeasurement": true },
+                "isVisionRequest": { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth", "comment": "Whether the request was for a vision model", "isMeasurement": true },
+                "isBYOK": { "classification": "SystemMetaData", "purpose": "FeatureInsight", "comment": "Whether the request was for a BYOK model", "isMeasurement": true },
+                "isAuto": { "classification": "SystemMetaData", "purpose": "FeatureInsight", "comment": "Whether the request was for an Auto model", "isMeasurement": true },
+                "retryAfterErrorCategory": { "classification": "SystemMetaData", "purpose": "FeatureInsight", "comment": "If the response failed and this is a retry attempt, this contains the error category." },
+                "retryAfterFilterCategory": { "classification": "SystemMetaData", "purpose": "FeatureInsight", "comment": "If the response was filtered and this is a retry attempt, this contains the original filtered content category." }
             }
-            else {
-                try {
-                    token = (await this._authenticationService.getCopilotToken()).token;
-                }
-                catch (_err) {
-                    // Ignore error
-                    token = '';
-                }
-            }
-            authHeaders['Authorization'] = `Bearer ${token}`;
-        }
-        return authHeaders;
-    }
-    async _fetchAndStreamChat(chatEndpointInfo, request, baseTelemetryData, finishedCb, secretKey, copilotToken, location, ourRequestId, nChoices, cancellationToken, userInitiatedRequest, telemetryProperties, useFetcher) {
-        if (cancellationToken.isCancellationRequested) {
-            return { type: fetch_2.FetchResponseKind.Canceled, reason: 'before fetch request' };
-        }
-        this._logService.debug(`modelMaxPromptTokens ${chatEndpointInfo.modelMaxPromptTokens}`);
-        this._logService.debug(`modelMaxResponseTokens ${request.max_tokens ?? 2048}`);
-        this._logService.debug(`chat model ${chatEndpointInfo.model}`);
-        secretKey ??= copilotToken.token;
-        if (!secretKey) {
-            // If no key is set we error
-            const urlOrRequestMetadata = (0, networking_1.stringifyUrlOrRequestMetadata)(chatEndpointInfo.urlOrRequestMetadata);
-            this._logService.error(`Failed to send request to ${urlOrRequestMetadata} due to missing key`);
-            (0, stream_1.sendCommunicationErrorTelemetry)(this._telemetryService, `Failed to send request to ${urlOrRequestMetadata} due to missing key`);
-            return {
-                type: fetch_2.FetchResponseKind.Failed,
-                modelRequestId: undefined,
-                failKind: fetch_2.ChatFailKind.TokenExpiredOrInvalid,
-                reason: 'key is missing'
-            };
-        }
-        // Generate unique ID to link input and output messages
-        const modelCallId = (0, uuid_1.generateUuid)();
-        const response = await this._fetchWithInstrumentation(chatEndpointInfo, ourRequestId, request, secretKey, location, cancellationToken, userInitiatedRequest, { ...telemetryProperties, modelCallId }, useFetcher);
-        if (cancellationToken.isCancellationRequested) {
-            const body = await response.body();
-            try {
-                // Destroy the stream so that the server is hopefully notified we don't want any more data
-                // and can cancel/forget about the request itself.
-                body.destroy();
-            }
-            catch (e) {
-                this._logService.error(e, `Error destroying stream`);
-                this._telemetryService.sendGHTelemetryException(e, 'Error destroying stream');
-            }
-            return { type: fetch_2.FetchResponseKind.Canceled, reason: 'after fetch request' };
-        }
-        if (response.status === 200 && this._authenticationService.copilotToken?.isFreeUser && this._authenticationService.copilotToken?.isChatQuotaExceeded) {
-            this._authenticationService.resetCopilotToken();
-        }
-        if (response.status !== 200) {
-            const telemetryData = createTelemetryData(chatEndpointInfo, location, ourRequestId);
-            this._logService.info('Request ID for failed request: ' + ourRequestId);
-            return this._handleError(telemetryData, response, ourRequestId);
-        }
-        // Extend baseTelemetryData with modelCallId for output messages
-        const extendedBaseTelemetryData = baseTelemetryData.extendedBy({ modelCallId });
-        const chatCompletions = await chatEndpointInfo.processResponseFromChatEndpoint(this._telemetryService, this._logService, response, nChoices ?? /* OpenAI's default */ 1, finishedCb, extendedBaseTelemetryData, cancellationToken);
-        // CAPI will return us a Copilot Edits Session Header which is our token to using the speculative decoding endpoint
-        // We should store this in the auth service for easy use later
-        if (response.headers.get('Copilot-Edits-Session')) {
-            this._authenticationService.speculativeDecodingEndpointToken = response.headers.get('Copilot-Edits-Session') ?? undefined;
-        }
-        this._chatQuotaService.processQuotaHeaders(response.headers);
-        return {
-            type: fetch_2.FetchResponseKind.Success,
-            chatCompletions,
-        };
-    }
-    async _fetchWithInstrumentation(chatEndpoint, ourRequestId, request, secretKey, location, cancellationToken, userInitiatedRequest, telemetryProperties, useFetcher) {
-        // If request contains an image, we include this header.
-        const additionalHeaders = {
-            'X-Interaction-Id': this._interactionService.interactionId,
-            'X-Initiator': userInitiatedRequest ? 'user' : 'agent', // Agent = a system request / not the primary user query.
-        };
-        if (request.messages?.some((m) => Array.isArray(m.content) ? m.content.some(c => 'image_url' in c) : false) && chatEndpoint.supportsVision) {
-            additionalHeaders['Copilot-Vision-Request'] = 'true';
-        }
-        const telemetryData = telemetryData_1.TelemetryData.createAndMarkAsIssued({
-            endpoint: 'completions',
-            engineName: 'chat',
-            uiKind: commonTypes_1.ChatLocation.toString(location),
-            ...telemetryProperties // This includes the modelCallId from fetchAndStreamChat
+        */
+        this._telemetryService.sendTelemetryEvent('response.cancelled', { github: true, microsoft: true }, {
+            apiType,
+            source,
+            requestId,
+            model,
+            associatedRequestId,
         }, {
-            maxTokenWindow: chatEndpoint.modelMaxPromptTokens
-        });
-        for (const [key, value] of Object.entries(request)) {
-            if (key === 'messages' || key === 'input') {
-                continue;
-            } // Skip messages (PII)
-            telemetryData.properties[`request.option.${key}`] = JSON.stringify(value) ?? 'undefined';
-        }
-        // The request ID we are passed in is sent in the request to the proxy, and included in our pre-request telemetry.
-        // We hope (but do not rely on) that the model will use the same ID in the response, allowing us to correlate
-        // the request and response.
-        telemetryData.properties['headerRequestId'] = ourRequestId;
-        this._telemetryService.sendGHTelemetryEvent('request.sent', telemetryData.properties, telemetryData.measurements);
-        const requestStart = Date.now();
-        const intent = locationToIntent(location);
-        // Wrap the Promise with success/error callbacks so we can log/measure it
-        return (0, networking_1.postRequest)(this._fetcherService, this._telemetryService, this._capiClientService, chatEndpoint, secretKey, await (0, crypto_1.createRequestHMAC)(process.env.HMAC_SECRET), intent, ourRequestId, request, additionalHeaders, cancellationToken, useFetcher).then(response => {
-            const apim = response.headers.get('apim-request-id');
-            if (apim) {
-                this._logService.debug(`APIM request id: ${apim}`);
-            }
-            const ghRequestId = response.headers.get('x-github-request-id');
-            if (ghRequestId) {
-                this._logService.debug(`GH request id: ${ghRequestId}`);
-            }
-            // This ID is hopefully the one the same as ourRequestId, but it is not guaranteed.
-            // If they are different then we will override the original one we set in telemetryData above.
-            const modelRequestId = (0, fetch_1.getRequestId)(response, undefined);
-            telemetryData.extendWithRequestId(modelRequestId);
-            // TODO: Add response length (requires parsing)
-            const totalTimeMs = Date.now() - requestStart;
-            telemetryData.measurements.totalTimeMs = totalTimeMs;
-            this._logService.debug(`request.response: [${(0, networking_1.stringifyUrlOrRequestMetadata)(chatEndpoint.urlOrRequestMetadata)}], took ${totalTimeMs} ms`);
-            this._telemetryService.sendGHTelemetryEvent('request.response', telemetryData.properties, telemetryData.measurements);
-            return response;
-        })
-            .catch(error => {
-            if (this._fetcherService.isAbortError(error)) {
-                // If we cancelled a network request, we don't want to log a `request.error`
-                throw error;
-            }
-            const warningTelemetry = telemetryData.extendedBy({ error: 'Network exception' });
-            this._telemetryService.sendGHTelemetryEvent('request.shownWarning', warningTelemetry.properties, warningTelemetry.measurements);
-            telemetryData.properties.code = String(error.code ?? '');
-            telemetryData.properties.errno = String(error.errno ?? '');
-            telemetryData.properties.message = String(error.message ?? '');
-            telemetryData.properties.type = String(error.type ?? '');
-            const totalTimeMs = Date.now() - requestStart;
-            telemetryData.measurements.totalTimeMs = totalTimeMs;
-            this._logService.debug(`request.response: [${(0, networking_1.stringifyUrlOrRequestMetadata)(chatEndpoint.urlOrRequestMetadata)}] took ${totalTimeMs} ms`);
-            this._telemetryService.sendGHTelemetryEvent('request.error', telemetryData.properties, telemetryData.measurements);
-            throw error;
-        })
-            .finally(() => {
-            (0, chatStream_1.sendEngineMessagesTelemetry)(this._telemetryService, request.messages ?? [], telemetryData, false, this._logService);
+            totalTokenMax,
+            promptTokenCount,
+            tokenCountMax,
+            timeToFirstToken,
+            timeToFirstTokenEmitted,
+            timeToCancelled,
+            isVisionRequest,
+            isBYOK,
+            isAuto
         });
     }
-    async _handleError(telemetryData, response, requestId) {
-        const modelRequestIdObj = (0, fetch_1.getRequestId)(response, undefined);
-        requestId = modelRequestIdObj.headerRequestId || requestId;
-        modelRequestIdObj.headerRequestId = requestId;
-        telemetryData.properties.error = `Response status was ${response.status}`;
-        telemetryData.properties.status = String(response.status);
-        this._telemetryService.sendGHTelemetryEvent('request.shownWarning', telemetryData.properties, telemetryData.measurements);
-        const text = await response.text();
-        let jsonData;
-        try {
-            jsonData = JSON.parse(text);
-            jsonData = jsonData?.error ?? jsonData; // Extract nested error object if it exists
-        }
-        catch {
-            // JSON parsing failed, it's not json content.
-        }
-        const reasonNoText = `Server error: ${response.status}`;
-        const reason = `${reasonNoText} ${text}`;
-        this._logService.error(reason);
-        if (400 <= response.status && response.status < 500) {
-            if (response.status === 400 && text.includes('off_topic')) {
-                return {
-                    type: fetch_2.FetchResponseKind.Failed,
-                    modelRequestId: modelRequestIdObj,
-                    failKind: fetch_2.ChatFailKind.OffTopic,
-                    reason: 'filtered as off_topic by intent classifier: message was not programming related',
-                };
-            }
-            if (response.status === 401 && text.includes('authorize_url') && jsonData?.authorize_url) {
-                return {
-                    type: fetch_2.FetchResponseKind.Failed,
-                    modelRequestId: modelRequestIdObj,
-                    failKind: fetch_2.ChatFailKind.AgentUnauthorized,
-                    reason: response.statusText || response.statusText,
-                    data: jsonData
-                };
-            }
-            if (response.status === 400 && jsonData?.code === 'previous_response_not_found') {
-                return {
-                    type: fetch_2.FetchResponseKind.Failed,
-                    modelRequestId: modelRequestIdObj,
-                    failKind: fetch_2.ChatFailKind.InvalidPreviousResponseId,
-                    reason: jsonData.message || 'Invalid previous response ID',
-                    data: jsonData,
-                };
-            }
-            if (response.status === 401 || response.status === 403) {
-                // Token has expired or invalid, fetch a new one on next request
-                // TODO(drifkin): these actions should probably happen in vsc specific code
-                this._authenticationService.resetCopilotToken(response.status);
-                return {
-                    type: fetch_2.FetchResponseKind.Failed,
-                    modelRequestId: modelRequestIdObj,
-                    failKind: fetch_2.ChatFailKind.TokenExpiredOrInvalid,
-                    reason: jsonData?.message || `token expired or invalid: ${response.status}`,
-                };
-            }
-            if (response.status === 402) {
-                // When we receive a 402, we have exceed a quota
-                // This is stored on the token so let's refresh it
-                this._authenticationService.resetCopilotToken(response.status);
-                const retryAfter = response.headers.get('retry-after');
-                const convertToDate = (retryAfterString) => {
-                    if (!retryAfterString) {
-                        return undefined;
-                    }
-                    // Try treating it as a date
-                    const retryAfterDate = new Date(retryAfterString);
-                    if (!isNaN(retryAfterDate.getDate())) {
-                        return retryAfterDate;
-                    }
-                    // It is not a date, try treating it as a duration from the current date
-                    const retryAfterDuration = parseInt(retryAfterString, 10);
-                    if (isNaN(retryAfterDuration)) {
-                        return undefined;
-                    }
-                    return new Date(Date.now() + retryAfterDuration * 1000);
-                };
-                const retryAfterDate = convertToDate(retryAfter);
-                return {
-                    type: fetch_2.FetchResponseKind.Failed,
-                    modelRequestId: modelRequestIdObj,
-                    failKind: fetch_2.ChatFailKind.QuotaExceeded,
-                    reason: jsonData?.message ?? 'Free tier quota exceeded',
-                    data: {
-                        capiError: jsonData,
-                        retryAfter: retryAfterDate
-                    }
-                };
-            }
-            if (response.status === 404) {
-                let errorReason;
-                // Check if response body is valid JSON
-                if (!jsonData) {
-                    errorReason = text;
-                }
-                else {
-                    errorReason = JSON.stringify(jsonData);
-                }
-                return {
-                    type: fetch_2.FetchResponseKind.Failed,
-                    modelRequestId: modelRequestIdObj,
-                    failKind: fetch_2.ChatFailKind.NotFound,
-                    reason: errorReason
-                };
-            }
-            if (response.status === 422) {
-                return {
-                    type: fetch_2.FetchResponseKind.Failed,
-                    modelRequestId: modelRequestIdObj,
-                    failKind: fetch_2.ChatFailKind.ContentFilter,
-                    reason: 'Filtered by Responsible AI Service\n\n' + text,
-                };
-            }
-            if (response.status === 424) {
-                return {
-                    type: fetch_2.FetchResponseKind.Failed,
-                    modelRequestId: modelRequestIdObj,
-                    failKind: fetch_2.ChatFailKind.AgentFailedDependency,
-                    reason: text
-                };
-            }
-            if (response.status === 429) {
-                let rateLimitReason = text;
-                rateLimitReason = jsonData?.message ?? jsonData?.code;
-                if (text.includes('extension_blocked') && jsonData?.code === 'extension_blocked' && jsonData?.type === 'rate_limit_error') {
-                    return {
-                        type: fetch_2.FetchResponseKind.Failed,
-                        modelRequestId: modelRequestIdObj,
-                        failKind: fetch_2.ChatFailKind.ExtensionBlocked,
-                        reason: 'Extension blocked',
-                        data: {
-                            ...jsonData?.message,
-                            retryAfter: response.headers.get('retry-after'),
-                        }
-                    };
-                }
-                // HTTP 429 Too Many Requests
-                return {
-                    type: fetch_2.FetchResponseKind.Failed,
-                    modelRequestId: modelRequestIdObj,
-                    failKind: fetch_2.ChatFailKind.RateLimited,
-                    reason: rateLimitReason,
-                    data: {
-                        retryAfter: response.headers.get('retry-after'),
-                        rateLimitKey: response.headers.get('x-ratelimit-exceeded'),
-                        capiError: jsonData
-                    }
-                };
-            }
-            if (response.status === 466) {
-                this._logService.info(text);
-                return {
-                    type: fetch_2.FetchResponseKind.Failed,
-                    modelRequestId: modelRequestIdObj,
-                    failKind: fetch_2.ChatFailKind.ClientNotSupported,
-                    reason: `client not supported: ${text}`
-                };
+    _sendResponseErrorTelemetry(processed, telemetryProperties, ourRequestId, chatEndpointInfo, requestBody, tokenCount, maxResponseTokens, timeToFirstToken, isVisionRequest) {
+        /* __GDPR__
+            "response.error" : {
+                "owner": "digitarald",
+                "comment": "Report quality issue for when a service response failed.",
+                "type": { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth", "comment": "Type of issue" },
+                "reason": { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth", "comment": "Reason of issue" },
+                "model": { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth", "comment": "Model selection for the response" },
+                "apiType": { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth", "comment": "API type for the response- chat completions or responses" },
+                "source": { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth", "comment": "Source for why the request was made" },
+                "requestId": { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth", "comment": "Id of the request" },
+                "associatedRequestId": { "classification": "SystemMetaData", "purpose": "FeatureInsight", "comment": "Another request ID that this request is associated with (eg, the originating request of a summarization request)." },
+                "reasoningEffort": { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth", "comment": "Reasoning effort level" },
+                "reasoningSummary": { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth", "comment": "Reasoning summary level" },
+                "totalTokenMax": { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth", "comment": "Maximum total token window", "isMeasurement": true },
+                "promptTokenCount": { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth", "comment": "Number of prompt tokens", "isMeasurement": true },
+                "tokenCountMax": { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth", "comment": "Maximum generated tokens", "isMeasurement": true },
+                "timeToFirstToken": { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth", "comment": "Time to first token", "isMeasurement": true },
+                "timeToFirstTokenEmitted": { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth", "comment": "Time to first token emitted (visible text)", "isMeasurement": true },
+                "isVisionRequest": { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth", "comment": "Whether the request was for a vision model", "isMeasurement": true },
+                "isBYOK": { "classification": "SystemMetaData", "purpose": "FeatureInsight", "comment": "Whether the request was for a BYOK model", "isMeasurement": true },
+                "isAuto": { "classification": "SystemMetaData", "purpose": "FeatureInsight", "comment": "Whether the request was for an Auto model", "isMeasurement": true },
+                "retryAfterErrorCategory": { "classification": "SystemMetaData", "purpose": "FeatureInsight", "comment": "If the response failed and this is a retry attempt, this contains the error category." },
+                "retryAfterFilterCategory": { "classification": "SystemMetaData", "purpose": "FeatureInsight", "comment": "If the response was filtered and this is a retry attempt, this contains the original filtered content category." }
             }
-            if (response.status === 499) {
-                this._logService.info('Cancelled by server');
-                return {
-                    type: fetch_2.FetchResponseKind.Failed,
-                    modelRequestId: modelRequestIdObj,
-                    failKind: fetch_2.ChatFailKind.ServerCanceled,
-                    reason: 'canceled by server'
-                };
-            }
-        }
-        else if (500 <= response.status && response.status < 600) {
-            if (response.status === 503) {
-                return {
-                    type: fetch_2.FetchResponseKind.Failed,
-                    modelRequestId: modelRequestIdObj,
-                    failKind: fetch_2.ChatFailKind.RateLimited,
-                    reason: 'Upstream provider rate limit hit',
-                    data: {
-                        retryAfter: null,
-                        rateLimitKey: null,
-                        capiError: { code: 'upstream_provider_rate_limit', message: text }
-                    }
-                };
-            }
-            // HTTP 5xx Server Error
-            return {
-                type: fetch_2.FetchResponseKind.Failed,
-                modelRequestId: modelRequestIdObj,
-                failKind: fetch_2.ChatFailKind.ServerError,
-                reason: reasonNoText,
-            };
-        }
-        this._logService.error(`Request Failed: ${response.status} ${text}`);
-        (0, stream_1.sendCommunicationErrorTelemetry)(this._telemetryService, 'Unhandled status from server: ' + response.status, text);
-        return {
-            type: fetch_2.FetchResponseKind.Failed,
-            modelRequestId: modelRequestIdObj,
-            failKind: fetch_2.ChatFailKind.Unknown,
-            reason: `Request Failed: ${response.status} ${text}`
-        };
+        */
+        this._telemetryService.sendTelemetryEvent('response.error', { github: true, microsoft: true }, {
+            type: processed.type,
+            reason: processed.reasonDetail || processed.reason,
+            source: telemetryProperties?.messageSource ?? 'unknown',
+            requestId: ourRequestId,
+            model: chatEndpointInfo.model,
+            apiType: chatEndpointInfo.apiType,
+            reasoningEffort: requestBody.reasoning?.effort,
+            reasoningSummary: requestBody.reasoning?.summary,
+            associatedRequestId: telemetryProperties?.associatedRequestId,
+            ...(telemetryProperties?.retryAfterErrorCategory ? { retryAfterErrorCategory: telemetryProperties.retryAfterErrorCategory } : {}),
+            ...(telemetryProperties?.retryAfterFilterCategory ? { retryAfterFilterCategory: telemetryProperties.retryAfterFilterCategory } : {})
+        }, {
+            totalTokenMax: chatEndpointInfo.modelMaxPromptTokens ?? -1,
+            promptTokenCount: tokenCount,
+            tokenCountMax: maxResponseTokens,
+            timeToFirstToken,
+            isVisionRequest: isVisionRequest ? 1 : -1,
+            isBYOK: (0, openAIEndpoint_1.isBYOKModel)(chatEndpointInfo),
+            isAuto: (0, autoChatEndpoint_1.isAutoModel)(chatEndpointInfo)
+        });
     }
     async processSuccessfulResponse(response, messages, requestBody, requestId, maxResponseTokens, promptTokenCount, timeToFirstToken, streamRecorder, baseTelemetry, chatEndpointInfo, userInitiatedRequest) {
         const completions = [];
         for await (const chatCompletion of response.chatCompletions) {
-            chatMLFetcherTelemetry_1.ChatMLFetcherTelemetrySender.sendSuccessTelemetry(this._telemetryService, {
-                chatCompletion,
-                baseTelemetry,
-                userInitiatedRequest,
-                chatEndpointInfo,
-                requestBody,
-                maxResponseTokens,
-                promptTokenCount,
+            /* __GDPR__
+                "response.success" : {
+                    "owner": "digitarald",
+                    "comment": "Report quality details for a successful service response.",
+                    "reason": { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth", "comment": "Reason for why a response finished" },
+                    "filterReason": { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth", "comment": "Reason for why a response was filtered" },
+                    "source": { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth", "comment": "Source of the initial request" },
+                    "initiatorType": { "classification": "SystemMetaData", "purpose": "FeatureInsight", "comment": "Whether the request was initiated by a user or an agent" },
+                    "model": { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth", "comment": "Model selection for the response" },
+                    "modelInvoked": { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth", "comment": "Actual model invoked for the response" },
+                    "apiType": { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth", "comment": "API type for the response- chat completions or responses" },
+                    "requestId": { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth", "comment": "Id of the current turn request" },
+                    "associatedRequestId": { "classification": "SystemMetaData", "purpose": "FeatureInsight", "comment": "Another request ID that this request is associated with (eg, the originating request of a summarization request)." },
+                    "reasoningEffort": { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth", "comment": "Reasoning effort level" },
+                    "reasoningSummary": { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth", "comment": "Reasoning summary level" },
+                    "totalTokenMax": { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth", "comment": "Maximum total token window", "isMeasurement": true },
+                    "clientPromptTokenCount": { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth", "comment": "Number of prompt tokens, locally counted", "isMeasurement": true },
+                    "promptTokenCount": { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth", "comment": "Number of prompt tokens, server side counted", "isMeasurement": true },
+                    "promptCacheTokenCount": { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth", "comment": "Number of prompt tokens hitting cache as reported by server", "isMeasurement": true },
+                    "tokenCountMax": { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth", "comment": "Maximum generated tokens", "isMeasurement": true },
+                    "tokenCount": { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth", "comment": "Number of generated tokens", "isMeasurement": true },
+                    "reasoningTokens": { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth", "comment": "Number of reasoning tokens", "isMeasurement": true },
+                    "acceptedPredictionTokens": { "classification": "SystemMetaData", "purpose": "FeatureInsight", "comment": "Number of tokens in the prediction that appeared in the completion", "isMeasurement": true },
+                    "rejectedPredictionTokens": { "classification": "SystemMetaData", "purpose": "FeatureInsight", "comment": "Number of tokens in the prediction that appeared in the completion", "isMeasurement": true },
+                    "completionTokens": { "classification": "SystemMetaData", "purpose": "FeatureInsight", "comment": "Number of tokens in the output", "isMeasurement": true },
+                    "timeToFirstToken": { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth", "comment": "Time to first token", "isMeasurement": true },
+                    "timeToFirstTokenEmitted": { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth", "comment": "Time to first token emitted (visible text)", "isMeasurement": true },
+                    "timeToComplete": { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth", "comment": "Time to complete the request", "isMeasurement": true },
+                    "isVisionRequest": { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth", "comment": "Whether the request was for a vision model", "isMeasurement": true },
+                    "isBYOK": { "classification": "SystemMetaData", "purpose": "FeatureInsight", "comment": "Whether the request was for a BYOK model", "isMeasurement": true },
+                    "isAuto": { "classification": "SystemMetaData", "purpose": "FeatureInsight", "comment": "Whether the request was for an Auto model", "isMeasurement": true },
+                    "retryAfterErrorCategory": { "classification": "SystemMetaData", "purpose": "FeatureInsight", "comment": "If the response failed and this is a retry attempt, this contains the error category." },
+                    "retryAfterFilterCategory": { "classification": "SystemMetaData", "purpose": "FeatureInsight", "comment": "If the response was filtered and this is a retry attempt, this contains the original filtered content category." }
+                }
+            */
+            this._telemetryService.sendTelemetryEvent('response.success', { github: true, microsoft: true }, {
+                reason: chatCompletion.finishReason,
+                filterReason: chatCompletion.filterReason,
+                source: baseTelemetry?.properties.messageSource ?? 'unknown',
+                initiatorType: userInitiatedRequest ? 'user' : 'agent',
+                model: chatEndpointInfo?.model,
+                modelInvoked: chatCompletion.model,
+                apiType: chatEndpointInfo?.apiType,
+                requestId,
+                associatedRequestId: baseTelemetry?.properties.associatedRequestId,
+                reasoningEffort: requestBody.reasoning?.effort,
+                reasoningSummary: requestBody.reasoning?.summary,
+                ...(baseTelemetry?.properties.retryAfterErrorCategory ? { retryAfterErrorCategory: baseTelemetry.properties.retryAfterErrorCategory } : {}),
+                ...(baseTelemetry?.properties.retryAfterFilterCategory ? { retryAfterFilterCategory: baseTelemetry.properties.retryAfterFilterCategory } : {}),
+            }, {
+                totalTokenMax: chatEndpointInfo?.modelMaxPromptTokens ?? -1,
+                tokenCountMax: maxResponseTokens,
+                promptTokenCount: chatCompletion.usage?.prompt_tokens,
+                promptCacheTokenCount: chatCompletion.usage?.prompt_tokens_details?.cached_tokens,
+                clientPromptTokenCount: promptTokenCount,
+                tokenCount: chatCompletion.usage?.total_tokens,
+                reasoningTokens: chatCompletion.usage?.completion_tokens_details?.reasoning_tokens,
+                acceptedPredictionTokens: chatCompletion.usage?.completion_tokens_details?.accepted_prediction_tokens,
+                rejectedPredictionTokens: chatCompletion.usage?.completion_tokens_details?.rejected_prediction_tokens,
+                completionTokens: chatCompletion.usage?.completion_tokens,
                 timeToFirstToken,
                 timeToFirstTokenEmitted: (baseTelemetry && streamRecorder.firstTokenEmittedTime) ? streamRecorder.firstTokenEmittedTime - baseTelemetry.issuedTime : -1,
-                hasImageMessages: this.filterImageMessages(messages),
+                timeToComplete: baseTelemetry ? Date.now() - baseTelemetry.issuedTime : -1,
+                isVisionRequest: this.filterImageMessages(messages) ? 1 : -1,
+                isBYOK: (0, openAIEndpoint_1.isBYOKModel)(chatEndpointInfo),
+                isAuto: (0, autoChatEndpoint_1.isAutoModel)(chatEndpointInfo)
             });
             if (!this.isRepetitive(chatCompletion, baseTelemetry?.properties)) {
                 completions.push(chatCompletion);
@@ -842,43 +564,43 @@ let ChatMLFetcherImpl = class ChatMLFetcherImpl extends AbstractChatMLFetcher {
     processFailedResponse(response, requestId) {
         const serverRequestId = response.modelRequestId?.gitHubRequestId;
         const reason = response.reason;
-        if (response.failKind === fetch_2.ChatFailKind.RateLimited) {
+        if (response.failKind === fetch_1.ChatFailKind.RateLimited) {
             return { type: commonTypes_1.ChatFetchResponseType.RateLimited, reason, requestId, serverRequestId, retryAfter: response.data?.retryAfter, rateLimitKey: (response.data?.rateLimitKey || ''), capiError: response.data?.capiError };
         }
-        if (response.failKind === fetch_2.ChatFailKind.QuotaExceeded) {
+        if (response.failKind === fetch_1.ChatFailKind.QuotaExceeded) {
             return { type: commonTypes_1.ChatFetchResponseType.QuotaExceeded, reason, requestId, serverRequestId, retryAfter: response.data?.retryAfter, capiError: response.data?.capiError };
         }
-        if (response.failKind === fetch_2.ChatFailKind.OffTopic) {
+        if (response.failKind === fetch_1.ChatFailKind.OffTopic) {
             return { type: commonTypes_1.ChatFetchResponseType.OffTopic, reason, requestId, serverRequestId };
         }
-        if (response.failKind === fetch_2.ChatFailKind.TokenExpiredOrInvalid || response.failKind === fetch_2.ChatFailKind.ClientNotSupported || reason.includes('Bad request: ')) {
+        if (response.failKind === fetch_1.ChatFailKind.TokenExpiredOrInvalid || response.failKind === fetch_1.ChatFailKind.ClientNotSupported || reason.includes('Bad request: ')) {
             return { type: commonTypes_1.ChatFetchResponseType.BadRequest, reason, requestId, serverRequestId };
         }
-        if (response.failKind === fetch_2.ChatFailKind.ServerError) {
+        if (response.failKind === fetch_1.ChatFailKind.ServerError) {
             return { type: commonTypes_1.ChatFetchResponseType.Failed, reason, requestId, serverRequestId };
         }
-        if (response.failKind === fetch_2.ChatFailKind.ContentFilter) {
+        if (response.failKind === fetch_1.ChatFailKind.ContentFilter) {
             return { type: commonTypes_1.ChatFetchResponseType.PromptFiltered, reason, category: openai_1.FilterReason.Prompt, requestId, serverRequestId };
         }
-        if (response.failKind === fetch_2.ChatFailKind.AgentUnauthorized) {
+        if (response.failKind === fetch_1.ChatFailKind.AgentUnauthorized) {
             return { type: commonTypes_1.ChatFetchResponseType.AgentUnauthorized, reason, authorizationUrl: response.data.authorize_url, requestId, serverRequestId };
         }
-        if (response.failKind === fetch_2.ChatFailKind.AgentFailedDependency) {
+        if (response.failKind === fetch_1.ChatFailKind.AgentFailedDependency) {
             return { type: commonTypes_1.ChatFetchResponseType.AgentFailedDependency, reason, requestId, serverRequestId };
         }
-        if (response.failKind === fetch_2.ChatFailKind.ExtensionBlocked) {
+        if (response.failKind === fetch_1.ChatFailKind.ExtensionBlocked) {
             const retryAfter = typeof response.data?.retryAfter === 'number' ? response.data.retryAfter : 300;
             return { type: commonTypes_1.ChatFetchResponseType.ExtensionBlocked, reason, requestId, retryAfter, learnMoreLink: response.data?.learnMoreLink ?? '', serverRequestId };
         }
-        if (response.failKind === fetch_2.ChatFailKind.NotFound) {
+        if (response.failKind === fetch_1.ChatFailKind.NotFound) {
             return { type: commonTypes_1.ChatFetchResponseType.NotFound, reason, requestId, serverRequestId };
         }
-        if (response.failKind === fetch_2.ChatFailKind.InvalidPreviousResponseId) {
+        if (response.failKind === fetch_1.ChatFailKind.InvalidPreviousResponseId) {
             return { type: commonTypes_1.ChatFetchResponseType.InvalidStatefulMarker, reason, requestId, serverRequestId };
         }
         return { type: commonTypes_1.ChatFetchResponseType.Failed, reason, requestId, serverRequestId };
     }
-    processError(err, requestId, usernameToScrub) {
+    processError(err, requestId) {
         const fetcher = this._fetcherService;
         // If we cancelled a network request, we don't want to log an error
         if (fetcher.isAbortError(err)) {
@@ -909,7 +631,7 @@ let ChatMLFetcherImpl = class ChatMLFetcherImpl extends AbstractChatMLFetcher {
         this._logService.error(errorsUtil.fromUnknown(err), `Error on conversation request`);
         this._telemetryService.sendGHTelemetryException(err, 'Error on conversation request');
         const errorDetail = fetcher.getUserMessageForFetcherError(err);
-        const scrubbedErrorDetail = this.scrubErrorDetail(errorDetail, usernameToScrub);
+        const scrubbedErrorDetail = this.scrubErrorDetail(errorDetail);
         if (fetcher.isInternetDisconnectedError(err)) {
             return {
                 type: commonTypes_1.ChatFetchResponseType.NetworkError,
@@ -938,12 +660,14 @@ let ChatMLFetcherImpl = class ChatMLFetcherImpl extends AbstractChatMLFetcher {
             };
         }
     }
-    scrubErrorDetail(errorDetail, usernameToScrub) {
-        if (usernameToScrub) {
-            const regex = new RegExp((0, strings_1.escapeRegExpCharacters)(usernameToScrub), 'ig');
-            errorDetail = errorDetail.replaceAll(regex, '<login>');
-        }
-        return errorDetail.replaceAll(/(?<=logged in as )(?!<login>)[^\s]+/ig, '!<login>!'); // marking fallback with !
+    scrubErrorDetail(errorDetail) {
+        errorDetail = errorDetail.replaceAll(/(logged in as )([^\s]+)/ig, '$1<login>');
+        const username = this._authenticationService.copilotToken?.username;
+        if (!username) {
+            return errorDetail;
+        }
+        const regex = new RegExp((0, strings_1.escapeRegExpCharacters)(username), 'ig');
+        return errorDetail.replaceAll(regex, '<login>');
     }
 };
 exports.ChatMLFetcherImpl = ChatMLFetcherImpl;
@@ -953,12 +677,8 @@ exports.ChatMLFetcherImpl = ChatMLFetcherImpl = __decorate([
     __param(2, requestLogger_1.IRequestLogger),
     __param(3, logService_1.ILogService),
     __param(4, authentication_1.IAuthenticationService),
-    __param(5, interactionService_1.IInteractionService),
-    __param(6, chatQuotaService_1.IChatQuotaService),
-    __param(7, capiClient_1.ICAPIClientService),
-    __param(8, conversationOptions_1.IConversationOptions),
-    __param(9, configurationService_1.IConfigurationService),
-    __param(10, nullExperimentationService_1.IExperimentationService)
+    __param(5, instantiation_1.IInstantiationService),
+    __param(6, conversationOptions_1.IConversationOptions)
 ], ChatMLFetcherImpl);
 /**
  * Validates a chat request payload to ensure it is valid
@@ -985,37 +705,4 @@ function isValidChatPayload(messages, postOptions) {
 function asUnexpected(reason) {
     return `Prompt failed validation with the reason: ${reason}. Please file an issue.`;
 }
-function createTelemetryData(chatEndpointInfo, location, headerRequestId) {
-    return telemetryData_1.TelemetryData.createAndMarkAsIssued({
-        endpoint: 'completions',
-        engineName: 'chat',
-        uiKind: commonTypes_1.ChatLocation.toString(location),
-        headerRequestId
-    });
-}
-/**
- * WARNING: The value that is returned from this function drives the disablement of RAI for full-file rewrite requests
- * in Copilot Edits, Copilot Chat, Agent Mode, and Inline Chat.
- * If your chat location generates full-file rewrite requests and you are unsure if changing something here will cause problems, please talk to @roblourens
- */
-function locationToIntent(location) {
-    switch (location) {
-        case commonTypes_1.ChatLocation.Panel:
-            return 'conversation-panel';
-        case commonTypes_1.ChatLocation.Editor:
-            return 'conversation-inline';
-        case commonTypes_1.ChatLocation.EditingSession:
-            return 'conversation-edits';
-        case commonTypes_1.ChatLocation.Notebook:
-            return 'conversation-notebook';
-        case commonTypes_1.ChatLocation.Terminal:
-            return 'conversation-terminal';
-        case commonTypes_1.ChatLocation.Other:
-            return 'conversation-other';
-        case commonTypes_1.ChatLocation.Agent:
-            return 'conversation-agent';
-        case commonTypes_1.ChatLocation.ResponsesProxy:
-            return 'responses-proxy';
-    }
-}
 //# sourceMappingURL=chatMLFetcher.js.map