@vscode/chat-lib 0.0.5-12 → 0.0.5-14

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

@@ -47,28 +47,39 @@ 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 fetch_1 = require("../../../platform/openai/node/fetch");
+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 requestLogger_1 = require("../../../platform/requestLogger/node/requestLogger");
 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 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");
 class AbstractChatMLFetcher {
     constructor(options) {
         this.options = options;
@@ -97,13 +108,16 @@ class AbstractChatMLFetcher {
 }
 exports.AbstractChatMLFetcher = AbstractChatMLFetcher;
 let ChatMLFetcherImpl = class ChatMLFetcherImpl extends AbstractChatMLFetcher {
-    constructor(_fetcherService, _telemetryService, _requestLogger, _logService, _instantiationService, options) {
+    constructor(_fetcherService, _telemetryService, _requestLogger, _logService, _authenticationService, _interactionService, _chatQuotaService, _capiClientService, options) {
         super(options);
         this._fetcherService = _fetcherService;
         this._telemetryService = _telemetryService;
         this._requestLogger = _requestLogger;
         this._logService = _logService;
-        this._instantiationService = _instantiationService;
+        this._authenticationService = _authenticationService;
+        this._interactionService = _interactionService;
+        this._chatQuotaService = _chatQuotaService;
+        this._capiClientService = _capiClientService;
     }
     /**
      * Note: the returned array of strings may be less than `n` (e.g., in case there were errors during streaming)
@@ -153,14 +167,14 @@ let ChatMLFetcherImpl = class ChatMLFetcherImpl extends AbstractChatMLFetcher {
             const payloadValidationResult = isValidChatPayload(opts.messages, postOptions);
             if (!payloadValidationResult.isValid) {
                 response = {
-                    type: fetch_1.FetchResponseKind.Failed,
+                    type: fetch_2.FetchResponseKind.Failed,
                     modelRequestId: undefined,
-                    failKind: fetch_1.ChatFailKind.ValidationFailed,
+                    failKind: fetch_2.ChatFailKind.ValidationFailed,
                     reason: payloadValidationResult.reason,
                 };
             }
             else {
-                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));
+                response = await this._fetchAndStreamChat(chatEndpoint, requestBody, baseTelemetry, streamRecorder.callback, requestOptions.secretKey, opts.location, ourRequestId, postOptions.n, token, userInitiatedRequest, telemetryProperties, opts.useFetcher);
                 tokenCount = await chatEndpoint.acquireTokenizer().countMessagesTokens(messages);
                 const extensionId = source?.extensionId ?? constants_1.EXTENSION_ID;
                 this._onDidMakeChatMLRequest.fire({
@@ -173,7 +187,7 @@ let ChatMLFetcherImpl = class ChatMLFetcherImpl extends AbstractChatMLFetcher {
             const timeToFirstToken = Date.now() - baseTelemetry.issuedTime;
             pendingLoggedChatRequest?.markTimeToFirstToken(timeToFirstToken);
             switch (response.type) {
-                case fetch_1.FetchResponseKind.Success: {
+                case fetch_2.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) {
@@ -223,8 +237,8 @@ let ChatMLFetcherImpl = class ChatMLFetcherImpl extends AbstractChatMLFetcher {
                     pendingLoggedChatRequest?.resolve(result, streamRecorder.deltas);
                     return result;
                 }
-                case fetch_1.FetchResponseKind.Canceled:
-                    this._sendCancellationTelemetry({
+                case fetch_2.FetchResponseKind.Canceled:
+                    chatMLFetcherTelemetry_1.ChatMLFetcherTelemetrySender.sendCancellationTelemetry(this._telemetryService, {
                         source: telemetryProperties.messageSource ?? 'unknown',
                         requestId: ourRequestId,
                         model: chatEndpoint.model,
@@ -245,9 +259,9 @@ let ChatMLFetcherImpl = class ChatMLFetcherImpl extends AbstractChatMLFetcher {
                     });
                     pendingLoggedChatRequest?.resolveWithCancelation();
                     return this.processCanceledResponse(response, ourRequestId);
-                case fetch_1.FetchResponseKind.Failed: {
+                case fetch_2.FetchResponseKind.Failed: {
                     const processed = this.processFailedResponse(response, ourRequestId);
-                    this._sendResponseErrorTelemetry(processed, telemetryProperties, ourRequestId, chatEndpoint, requestBody, tokenCount, maxResponseTokens, timeToFirstToken, this.filterImageMessages(messages));
+                    chatMLFetcherTelemetry_1.ChatMLFetcherTelemetrySender.sendResponseErrorTelemetry(this._telemetryService, processed, telemetryProperties, ourRequestId, chatEndpoint, requestBody, tokenCount, maxResponseTokens, timeToFirstToken, this.filterImageMessages(messages));
                     pendingLoggedChatRequest?.resolve(processed);
                     return processed;
                 }
@@ -281,7 +295,7 @@ let ChatMLFetcherImpl = class ChatMLFetcherImpl extends AbstractChatMLFetcher {
                 }
             }
             if (processed.type === commonTypes_1.ChatFetchResponseType.Canceled) {
-                this._sendCancellationTelemetry({
+                chatMLFetcherTelemetry_1.ChatMLFetcherTelemetrySender.sendCancellationTelemetry(this._telemetryService, {
                     source: telemetryProperties.messageSource ?? 'unknown',
                     requestId: ourRequestId,
                     model: chatEndpoint.model,
@@ -299,170 +313,357 @@ let ChatMLFetcherImpl = class ChatMLFetcherImpl extends AbstractChatMLFetcher {
                 });
             }
             else {
-                this._sendResponseErrorTelemetry(processed, telemetryProperties, ourRequestId, chatEndpoint, requestBody, tokenCount, maxResponseTokens, timeToError, this.filterImageMessages(messages));
+                chatMLFetcherTelemetry_1.ChatMLFetcherTelemetrySender.sendResponseErrorTelemetry(this._telemetryService, processed, telemetryProperties, ourRequestId, chatEndpoint, requestBody, tokenCount, maxResponseTokens, timeToError, this.filterImageMessages(messages));
             }
             pendingLoggedChatRequest?.resolve(processed);
             return processed;
         }
     }
-    _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." }
+    async _fetchAndStreamChat(chatEndpointInfo, request, baseTelemetryData, finishedCb, secretKey, 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 ??= (await this._authenticationService.getCopilotToken()).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');
             }
-        */
-        this._telemetryService.sendTelemetryEvent('response.cancelled', { github: true, microsoft: true }, {
-            apiType,
-            source,
-            requestId,
-            model,
-            associatedRequestId,
+            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
         }, {
-            totalTokenMax,
-            promptTokenCount,
-            tokenCountMax,
-            timeToFirstToken,
-            timeToFirstTokenEmitted,
-            timeToCancelled,
-            isVisionRequest,
-            isBYOK,
-            isAuto
+            maxTokenWindow: chatEndpoint.modelMaxPromptTokens
         });
-    }
-    _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." }
+        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}`);
             }
-        */
-        this._telemetryService.sendTelemetryEvent('response.error', { github: true, microsoft: true }, {
-            type: processed.type,
-            reason: 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)
+            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);
         });
     }
+    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.
+        }
+        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'
+                };
+            }
+            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}`
+                };
+            }
+            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 }
+                    }
+                };
+            }
+            const reasonNoText = `Server error: ${response.status}`;
+            const reason = `${reasonNoText} ${text}`;
+            this._logService.error(reason);
+            // 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}`
+        };
+    }
     async processSuccessfulResponse(response, messages, requestBody, requestId, maxResponseTokens, promptTokenCount, timeToFirstToken, streamRecorder, baseTelemetry, chatEndpointInfo, userInitiatedRequest) {
         const completions = [];
         for await (const chatCompletion of response.chatCompletions) {
-            /* __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,
+            chatMLFetcherTelemetry_1.ChatMLFetcherTelemetrySender.sendSuccessTelemetry(this._telemetryService, {
                 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,
+                chatCompletion,
+                baseTelemetry,
+                userInitiatedRequest,
+                chatEndpointInfo,
+                requestBody,
+                maxResponseTokens,
+                promptTokenCount,
                 timeToFirstToken,
                 timeToFirstTokenEmitted: (baseTelemetry && streamRecorder.firstTokenEmittedTime) ? streamRecorder.firstTokenEmittedTime - baseTelemetry.issuedTime : -1,
-                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)
+                hasImageMessages: this.filterImageMessages(messages),
             });
             if (!this.isRepetitive(chatCompletion, baseTelemetry?.properties)) {
                 completions.push(chatCompletion);
@@ -561,38 +762,38 @@ let ChatMLFetcherImpl = class ChatMLFetcherImpl extends AbstractChatMLFetcher {
     processFailedResponse(response, requestId) {
         const serverRequestId = response.modelRequestId?.gitHubRequestId;
         const reason = response.reason;
-        if (response.failKind === fetch_1.ChatFailKind.RateLimited) {
+        if (response.failKind === fetch_2.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_1.ChatFailKind.QuotaExceeded) {
+        if (response.failKind === fetch_2.ChatFailKind.QuotaExceeded) {
             return { type: commonTypes_1.ChatFetchResponseType.QuotaExceeded, reason, requestId, serverRequestId, retryAfter: response.data?.retryAfter, capiError: response.data?.capiError };
         }
-        if (response.failKind === fetch_1.ChatFailKind.OffTopic) {
+        if (response.failKind === fetch_2.ChatFailKind.OffTopic) {
             return { type: commonTypes_1.ChatFetchResponseType.OffTopic, reason, requestId, serverRequestId };
         }
-        if (response.failKind === fetch_1.ChatFailKind.TokenExpiredOrInvalid || response.failKind === fetch_1.ChatFailKind.ClientNotSupported || reason.includes('Bad request: ')) {
+        if (response.failKind === fetch_2.ChatFailKind.TokenExpiredOrInvalid || response.failKind === fetch_2.ChatFailKind.ClientNotSupported || reason.includes('Bad request: ')) {
             return { type: commonTypes_1.ChatFetchResponseType.BadRequest, reason, requestId, serverRequestId };
         }
-        if (response.failKind === fetch_1.ChatFailKind.ServerError) {
+        if (response.failKind === fetch_2.ChatFailKind.ServerError) {
             return { type: commonTypes_1.ChatFetchResponseType.Failed, reason, requestId, serverRequestId };
         }
-        if (response.failKind === fetch_1.ChatFailKind.ContentFilter) {
+        if (response.failKind === fetch_2.ChatFailKind.ContentFilter) {
             return { type: commonTypes_1.ChatFetchResponseType.PromptFiltered, reason, category: openai_1.FilterReason.Prompt, requestId, serverRequestId };
         }
-        if (response.failKind === fetch_1.ChatFailKind.AgentUnauthorized) {
+        if (response.failKind === fetch_2.ChatFailKind.AgentUnauthorized) {
             return { type: commonTypes_1.ChatFetchResponseType.AgentUnauthorized, reason, authorizationUrl: response.data.authorize_url, requestId, serverRequestId };
         }
-        if (response.failKind === fetch_1.ChatFailKind.AgentFailedDependency) {
+        if (response.failKind === fetch_2.ChatFailKind.AgentFailedDependency) {
             return { type: commonTypes_1.ChatFetchResponseType.AgentFailedDependency, reason, requestId, serverRequestId };
         }
-        if (response.failKind === fetch_1.ChatFailKind.ExtensionBlocked) {
+        if (response.failKind === fetch_2.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_1.ChatFailKind.NotFound) {
+        if (response.failKind === fetch_2.ChatFailKind.NotFound) {
             return { type: commonTypes_1.ChatFetchResponseType.NotFound, reason, requestId, serverRequestId };
         }
-        if (response.failKind === fetch_1.ChatFailKind.InvalidPreviousResponseId) {
+        if (response.failKind === fetch_2.ChatFailKind.InvalidPreviousResponseId) {
             return { type: commonTypes_1.ChatFetchResponseType.InvalidStatefulMarker, reason, requestId, serverRequestId };
         }
         return { type: commonTypes_1.ChatFetchResponseType.Failed, reason, requestId, serverRequestId };
@@ -627,11 +828,12 @@ let ChatMLFetcherImpl = class ChatMLFetcherImpl extends AbstractChatMLFetcher {
         }
         this._logService.error(errorsUtil.fromUnknown(err), `Error on conversation request`);
         this._telemetryService.sendGHTelemetryException(err, 'Error on conversation request');
-        // this.logger.exception(err, `Error on conversation request`);
+        const errorDetail = fetcher.getUserMessageForFetcherError(err);
         if (fetcher.isInternetDisconnectedError(err)) {
             return {
                 type: commonTypes_1.ChatFetchResponseType.NetworkError,
                 reason: `It appears you're not connected to the internet, please check your network connection and try again.`,
+                reasonDetail: errorDetail,
                 requestId: requestId,
                 serverRequestId: undefined,
             };
@@ -639,7 +841,8 @@ let ChatMLFetcherImpl = class ChatMLFetcherImpl extends AbstractChatMLFetcher {
         else if (fetcher.isFetcherError(err)) {
             return {
                 type: commonTypes_1.ChatFetchResponseType.NetworkError,
-                reason: fetcher.getUserMessageForFetcherError(err),
+                reason: errorDetail,
+                reasonDetail: errorDetail,
                 requestId: requestId,
                 serverRequestId: undefined,
             };
@@ -648,6 +851,7 @@ let ChatMLFetcherImpl = class ChatMLFetcherImpl extends AbstractChatMLFetcher {
             return {
                 type: commonTypes_1.ChatFetchResponseType.Failed,
                 reason: 'Error on conversation request. Check the log for more details.',
+                reasonDetail: errorDetail,
                 requestId: requestId,
                 serverRequestId: undefined,
             };
@@ -660,8 +864,11 @@ exports.ChatMLFetcherImpl = ChatMLFetcherImpl = __decorate([
     __param(1, telemetry_1.ITelemetryService),
     __param(2, requestLogger_1.IRequestLogger),
     __param(3, logService_1.ILogService),
-    __param(4, instantiation_1.IInstantiationService),
-    __param(5, conversationOptions_1.IConversationOptions)
+    __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)
 ], ChatMLFetcherImpl);
 /**
  * Validates a chat request payload to ensure it is valid
@@ -688,4 +895,37 @@ 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