@codingame/monaco-vscode-api 37.6.0 → 38.0.0

package/vscode/src/vs/workbench/contrib/chat/common/chatService/chatServiceTelemetry.d.ts

@@ -0,0 +1,273 @@
+import { URI } from "../../../../../base/common/uri.js";
+import { IAgentHostConnectionsService } from "../../../../../platform/agentHost/common/agentHostConnectionsService.service.js";
+import { ITelemetryService } from "../../../../../platform/telemetry/common/telemetry.service.js";
+import { IChatAgentData } from "../participants/chatAgents.js";
+import { ChatRequestModel } from "../model/chatModel.js";
+import { ChatRequestAgentSubcommandPart, ChatRequestSlashCommandPart } from "../requestParser/chatParserTypes.js";
+import { IChatSendRequestOptions, IChatUserActionEvent } from "./chatService.js";
+import { ChatAgentLocation, ChatPermissionLevel } from "../constants.js";
+import { ILanguageModelsService } from "../languageModels.service.js";
+import { IChatSessionsService } from "../chatSessionsService.service.js";
+import { IChatEntitlementService } from "../../../../services/chat/common/chatEntitlementService.service.js";
+type ChatSessionModeEvent = {
+    isAgentHostSession: boolean;
+};
+type ChatSessionModeClassification = {
+    isAgentHostSession: {
+        classification: "SystemMetaData";
+        purpose: "FeatureInsight";
+        isMeasurement: true;
+        comment: "Whether the action was performed in an Agent Host-backed chat session.";
+    };
+};
+export type ChatProviderInvokedEvent = ChatSessionModeEvent & {
+    provider: string | undefined;
+    requestIndex: number;
+    timeToFirstProgress: number | undefined;
+    totalTime: number | undefined;
+    result: "success" | "error" | "errorWithOutput" | "cancelled" | "filtered";
+    requestType: "string" | "followup" | "slashCommand";
+    chatSessionId: string;
+    requestId: string;
+    agent: string;
+    agentExtensionId: string | undefined;
+    slashCommand: string | undefined;
+    location: ChatAgentLocation;
+    citations: number;
+    numCodeBlocks: number;
+    isParticipantDetected: boolean;
+    enableCommandDetection: boolean;
+    attachmentKinds: string[];
+    model: string | undefined;
+    requestStartCopilotSku: string | undefined;
+    selectedModelSource: "copilot" | "byok" | "other" | "unknown";
+    permissionLevel: ChatPermissionLevel | undefined;
+    chatMode: string | undefined;
+    sessionType: string | undefined;
+    harness: string | undefined;
+    sessionTypeSelectionReason: string | undefined;
+    isVirtualWorkspace: boolean;
+    settingDefaultToCopilotHarness: boolean;
+    settingPreferCopilotHarness: boolean;
+    settingLocalAgentEnabled: boolean;
+    settingCopilotHarnessIntroductionMode: string;
+};
+export type ChatProviderInvokedClassification = ChatSessionModeClassification & {
+    provider: {
+        classification: "SystemMetaData";
+        purpose: "FeatureInsight";
+        comment: "Identifies the agent implementation handling the associated chat session, such as copilotcli, claude, or codex.";
+    };
+    requestIndex: {
+        classification: "SystemMetaData";
+        purpose: "FeatureInsight";
+        isMeasurement: true;
+        comment: "The zero-based index of the request within the chat session.";
+    };
+    timeToFirstProgress: {
+        classification: "SystemMetaData";
+        purpose: "PerformanceAndHealth";
+        isMeasurement: true;
+        comment: "The time in milliseconds from invoking the provider to getting the first data.";
+    };
+    totalTime: {
+        classification: "SystemMetaData";
+        purpose: "PerformanceAndHealth";
+        isMeasurement: true;
+        comment: "The total time it took to run the provider's `provideResponseWithProgress`.";
+    };
+    result: {
+        classification: "SystemMetaData";
+        purpose: "FeatureInsight";
+        comment: "Whether invoking the ChatProvider resulted in an error.";
+    };
+    requestType: {
+        classification: "SystemMetaData";
+        purpose: "FeatureInsight";
+        comment: "The type of request that the user made.";
+    };
+    chatSessionId: {
+        classification: "SystemMetaData";
+        purpose: "FeatureInsight";
+        comment: "A random ID for the session.";
+    };
+    requestId: {
+        classification: "SystemMetaData";
+        purpose: "PerformanceAndHealth";
+        comment: "The identifier of the chat request, used to correlate workbench and agent host telemetry.";
+    };
+    agent: {
+        classification: "SystemMetaData";
+        purpose: "FeatureInsight";
+        comment: "The type of agent used.";
+    };
+    agentExtensionId: {
+        classification: "SystemMetaData";
+        purpose: "FeatureInsight";
+        comment: "The extension that contributed the agent.";
+    };
+    slashCommand?: {
+        classification: "SystemMetaData";
+        purpose: "FeatureInsight";
+        comment: "The type of slashCommand used.";
+    };
+    location: {
+        classification: "SystemMetaData";
+        purpose: "FeatureInsight";
+        comment: "The location at which chat request was made.";
+    };
+    citations: {
+        classification: "SystemMetaData";
+        purpose: "FeatureInsight";
+        isMeasurement: true;
+        comment: "The number of public code citations that were returned with the response.";
+    };
+    numCodeBlocks: {
+        classification: "SystemMetaData";
+        purpose: "FeatureInsight";
+        isMeasurement: true;
+        comment: "The number of code blocks in the response.";
+    };
+    isParticipantDetected: {
+        classification: "SystemMetaData";
+        purpose: "FeatureInsight";
+        isMeasurement: true;
+        comment: "Whether the participant was automatically detected.";
+    };
+    enableCommandDetection: {
+        classification: "SystemMetaData";
+        purpose: "FeatureInsight";
+        isMeasurement: true;
+        comment: "Whether participation detection was disabled for this invocation.";
+    };
+    attachmentKinds: {
+        classification: "SystemMetaData";
+        purpose: "FeatureInsight";
+        comment: "The types of variables/attachments that the user included with their query.";
+    };
+    model: {
+        classification: "SystemMetaData";
+        purpose: "FeatureInsight";
+        comment: "The model used to generate the response.";
+    };
+    requestStartCopilotSku: {
+        classification: "SystemMetaData";
+        purpose: "PerformanceAndHealth";
+        comment: "The workbench Copilot entitlement SKU when the request started, if known. Not the credential used by a remote host.";
+    };
+    selectedModelSource: {
+        classification: "SystemMetaData";
+        purpose: "PerformanceAndHealth";
+        comment: "Source of the selected model at request start: copilot catalog, explicitly marked byok, other catalog, or unknown. Not the actual routed model or billing provider.";
+    };
+    permissionLevel: {
+        classification: "SystemMetaData";
+        purpose: "FeatureInsight";
+        comment: "The tool auto-approval permission level selected in the permission picker (default, assisted, autoApprove, or autopilot). Undefined when the picker is not applicable (e.g. ask mode or API-driven requests).";
+    };
+    chatMode: {
+        classification: "SystemMetaData";
+        purpose: "FeatureInsight";
+        comment: "The chat mode used for the request. Built-in modes (ask, agent, edit), extension-contributed names (e.g. Plan), or a hashed identifier for user-created custom agents.";
+    };
+    sessionType: {
+        classification: "SystemMetaData";
+        purpose: "FeatureInsight";
+        comment: "The session type scheme (e.g. vscodeLocalChatSession for local, or remote session scheme).";
+    };
+    harness: {
+        classification: "SystemMetaData";
+        purpose: "FeatureInsight";
+        comment: "For remote agent host sessions, the underlying harness/provider (e.g. copilotcli, claude, codex) so remote activity can be split by harness. Undefined for non-remote sessions.";
+    };
+    sessionTypeSelectionReason: {
+        classification: "SystemMetaData";
+        purpose: "FeatureInsight";
+        comment: "Why the session type was selected when the session was created. Undefined for restored or reused sessions.";
+    };
+    isVirtualWorkspace: {
+        classification: "SystemMetaData";
+        purpose: "FeatureInsight";
+        isMeasurement: true;
+        comment: "Whether the chat request was made in a virtual workspace.";
+    };
+    settingDefaultToCopilotHarness: {
+        classification: "SystemMetaData";
+        purpose: "FeatureInsight";
+        isMeasurement: true;
+        comment: "The effective value of the chat.defaultToCopilotHarness setting when the request started.";
+    };
+    settingPreferCopilotHarness: {
+        classification: "SystemMetaData";
+        purpose: "FeatureInsight";
+        isMeasurement: true;
+        comment: "The effective value of the chat.editor.preferCopilotHarness setting when the request started.";
+    };
+    settingLocalAgentEnabled: {
+        classification: "SystemMetaData";
+        purpose: "FeatureInsight";
+        isMeasurement: true;
+        comment: "The effective value of the chat.editor.localAgent.enabled setting when the request started.";
+    };
+    settingCopilotHarnessIntroductionMode: {
+        classification: "SystemMetaData";
+        purpose: "FeatureInsight";
+        comment: "The effective Copilot harness introduction experiment mode when the request started.";
+    };
+    owner: "roblourens";
+    comment: "Provides insight into the performance of Chat agents.";
+};
+export declare class ChatServiceTelemetry {
+    private readonly telemetryService;
+    constructor(telemetryService: ITelemetryService);
+    notifyUserAction(action: IChatUserActionEvent): void;
+    retrievedFollowups(sessionResource: URI, agentId: string, command: string | undefined, numFollowups: number): void;
+}
+export declare class ChatRequestTelemetry {
+    private readonly opts;
+    private readonly telemetryService;
+    private readonly languageModelsService;
+    private readonly chatSessionsService;
+    private isComplete;
+    private readonly requestStartCopilotSku;
+    private readonly selectedModelSource;
+    constructor(opts: {
+        agent: IChatAgentData;
+        agentSlashCommandPart: ChatRequestAgentSubcommandPart | undefined;
+        commandPart: ChatRequestSlashCommandPart | undefined;
+        requestIndex: number;
+        sessionTypeSelectionReason: string | undefined;
+        sessionResource: URI;
+        location: ChatAgentLocation;
+        options: IChatSendRequestOptions | undefined;
+        enableCommandDetection: boolean;
+        isVirtualWorkspace: boolean;
+        settingDefaultToCopilotHarness: boolean;
+        settingPreferCopilotHarness: boolean;
+        settingLocalAgentEnabled: boolean;
+        settingCopilotHarnessIntroductionMode: string;
+    }, telemetryService: ITelemetryService, languageModelsService: ILanguageModelsService, chatSessionsService: IChatSessionsService, chatEntitlementService: IChatEntitlementService);
+    complete({ timeToFirstProgress, totalTime, result, requestType, request, detectedAgent }: {
+        timeToFirstProgress: number | undefined;
+        totalTime: number | undefined;
+        result: ChatProviderInvokedEvent["result"];
+        requestType: ChatProviderInvokedEvent["requestType"];
+        request: ChatRequestModel;
+        detectedAgent: IChatAgentData | undefined;
+    }): void;
+    private attachmentKindsForTelemetry;
+    private resolveModelId;
+}
+interface IChatSessionTelemetryContext {
+    readonly chatSessionId: string;
+    readonly sessionType: string;
+    readonly harness: string | undefined;
+}
+/** Preserves workbench chat IDs while resolving the owning Agent Host session, without its connection authority. */
+export declare function getChatSessionTelemetryIds(sessionResource: URI, connectionsService: Pick<IAgentHostConnectionsService, "resolveSessionResourceIdentity">): {
+    chatSessionId: string;
+    agentSessionId?: string;
+};
+/** Returns telemetry-safe session context, excluding remote Agent Host connection authorities. */
+export declare function getChatSessionTelemetryContext(sessionResource: URI): IChatSessionTelemetryContext;
+export {};

package/vscode/src/vs/workbench/contrib/chat/common/chatService/chatServiceTelemetry.js

@@ -0,0 +1,280 @@
+
+import { __decorate, __param } from '../../../../../../../../external/tslib/tslib.es6.js';
+import { URI } from '../../../../../base/common/uri.js';
+import { AgentSession } from '../../../../../platform/agentHost/common/agent.js';
+import { isLocation } from '../../../../../editor/common/languages.js';
+import { escapeModelIdForTelemetry } from '../../../../../platform/telemetry/common/telemetry.js';
+import { ITelemetryService } from '../../../../../platform/telemetry/common/telemetry.service.js';
+import { ChatAgentVoteDirection, ChatCopyKind } from './chatService.js';
+import { isImageVariableEntry } from '../attachments/chatVariableEntries.js';
+import { ChatModeKind } from '../constants.js';
+import { COPILOT_VENDOR_ID } from '../languageModels.js';
+import { ILanguageModelsService } from '../languageModels.service.js';
+import { getChatSessionType, isUntitledChatSession, chatSessionResourceToId } from '../model/chatUri.js';
+import { getAgentHostProviderForTelemetry, isAgentHostSessionResource } from '../chatSessionsService.js';
+import { IChatSessionsService } from '../chatSessionsService.service.js';
+import { isCopilotAgentHostProvider, isRemoteAgentHostSessionType, parseRemoteAgentHostHarness } from '../../../../../platform/agentHost/common/agentHostSessionType.js';
+import { IChatEntitlementService } from '../../../../services/chat/common/chatEntitlementService.service.js';
+import { isByokModel } from '../chatSelectedModel.js';
+
+let ChatServiceTelemetry = class ChatServiceTelemetry {
+    constructor(telemetryService) {
+        this.telemetryService = telemetryService;
+    }
+    notifyUserAction(action) {
+        const isAgentHostSession = getIsAgentHostSessionForTelemetry(action.sessionResource);
+        if (action.action.kind === "vote") {
+            this.telemetryService.publicLog2("interactiveSessionVote", {
+                isAgentHostSession,
+                direction: action.action.direction === ChatAgentVoteDirection.Up ? "up" : "down",
+                agentId: action.agentId ?? "",
+                command: action.command
+            });
+        } else if (action.action.kind === "copy") {
+            this.telemetryService.publicLog2("interactiveSessionCopy", {
+                isAgentHostSession,
+                copyKind: action.action.copyKind === ChatCopyKind.Action ? "action" : "toolbar",
+                agentId: action.agentId ?? "",
+                command: action.command
+            });
+        } else if (action.action.kind === "insert") {
+            this.telemetryService.publicLog2("interactiveSessionInsert", {
+                isAgentHostSession,
+                newFile: !!action.action.newFile,
+                agentId: action.agentId ?? "",
+                command: action.command
+            });
+        } else if (action.action.kind === "apply") {
+            this.telemetryService.publicLog2("interactiveSessionApply", {
+                isAgentHostSession,
+                newFile: !!action.action.newFile,
+                codeMapper: action.action.codeMapper,
+                agentId: action.agentId ?? "",
+                command: action.command,
+                editsProposed: !!action.action.editsProposed
+            });
+        } else if (action.action.kind === "runInTerminal") {
+            this.telemetryService.publicLog2("interactiveSessionRunInTerminal", {
+                isAgentHostSession,
+                languageId: action.action.languageId ?? "",
+                agentId: action.agentId ?? "",
+                command: action.command
+            });
+        } else if (action.action.kind === "followUp") {
+            this.telemetryService.publicLog2("chatFollowupClicked", {
+                isAgentHostSession,
+                agentId: action.agentId ?? "",
+                command: action.command
+            });
+        } else if (action.action.kind === "chatEditingSessionAction") {
+            this.telemetryService.publicLog2("chatEditSession", {
+                isAgentHostSession,
+                agentId: action.agentId ?? "",
+                outcome: action.action.outcome,
+                hasRemainingEdits: action.action.hasRemainingEdits,
+                requestId: action.requestId,
+                modelId: escapeModelIdForTelemetry(action.modelId) ?? "",
+                modeId: action.modeId ?? ""
+            });
+        } else if (action.action.kind === "chatEditingHunkAction") {
+            this.telemetryService.publicLog2("chatEditHunk", {
+                isAgentHostSession,
+                agentId: action.agentId ?? "",
+                outcome: action.action.outcome,
+                lineCount: action.action.lineCount,
+                hasRemainingEdits: action.action.hasRemainingEdits,
+                requestId: action.requestId,
+                modelId: escapeModelIdForTelemetry(action.modelId) ?? "",
+                modeId: action.modeId ?? ""
+            });
+        }
+    }
+    retrievedFollowups(sessionResource, agentId, command, numFollowups) {
+        this.telemetryService.publicLog2("chatFollowupsRetrieved", {
+            isAgentHostSession: getIsAgentHostSessionForTelemetry(sessionResource),
+            agentId,
+            command,
+            numFollowups
+        });
+    }
+};
+ChatServiceTelemetry = ( __decorate([( __param(0, ITelemetryService))], ChatServiceTelemetry));
+function getCodeBlocks(text) {
+    const lines = text.split("\n");
+    const codeBlockLanguages = [];
+    let codeBlockState;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (codeBlockState) {
+            if (( new RegExp(`^\\s*${codeBlockState.delimiter}\\s*$`)).test(line)) {
+                codeBlockLanguages.push(codeBlockState.languageId);
+                codeBlockState = undefined;
+            }
+        } else {
+            const match = line.match(/^(\s*)(`{3,}|~{3,})(\w*)/);
+            if (match) {
+                codeBlockState = {
+                    delimiter: match[2],
+                    languageId: match[3]
+                };
+            }
+        }
+    }
+    return codeBlockLanguages;
+}
+let ChatRequestTelemetry = class ChatRequestTelemetry {
+    constructor(
+        opts,
+        telemetryService,
+        languageModelsService,
+        chatSessionsService,
+        chatEntitlementService
+    ) {
+        this.opts = opts;
+        this.telemetryService = telemetryService;
+        this.languageModelsService = languageModelsService;
+        this.chatSessionsService = chatSessionsService;
+        this.isComplete = false;
+        this.requestStartCopilotSku = chatEntitlementService.sku;
+        const selectedModel = opts.options?.userSelectedModelId;
+        const metadata = selectedModel ? languageModelsService.lookupLanguageModel(selectedModel) : undefined;
+        const modelProvider = metadata?.targetChatSessionType ? getAgentHostProviderForTelemetry(metadata.targetChatSessionType, chatSessionsService) : undefined;
+        this.selectedModelSource = !metadata ? "unknown" : isByokModel(metadata) ? "byok" : metadata.vendor === COPILOT_VENDOR_ID || isCopilotAgentHostProvider(modelProvider) ? "copilot" : metadata.targetChatSessionType && (!modelProvider || modelProvider === "unknown") ? "unknown" : "other";
+    }
+    complete(
+        {
+            timeToFirstProgress,
+            totalTime,
+            result,
+            requestType,
+            request,
+            detectedAgent
+        }
+    ) {
+        if (this.isComplete) {
+            return;
+        }
+        this.isComplete = true;
+        const agentId = detectedAgent?.id ?? this.opts.agent.id;
+        const provider = getAgentHostProviderForTelemetry(getChatSessionType(this.opts.sessionResource), this.chatSessionsService);
+        this.telemetryService.publicLog2("interactiveSessionProviderInvoked", {
+            provider,
+            requestIndex: this.opts.requestIndex,
+            sessionTypeSelectionReason: this.opts.sessionTypeSelectionReason,
+            timeToFirstProgress,
+            totalTime,
+            result,
+            requestType,
+            requestId: request.id,
+            agent: isRemoteAgentHostSessionType(agentId) ? "remote-agent-host" : agentId,
+            agentExtensionId: detectedAgent?.extensionId.value ?? this.opts.agent.extensionId.value,
+            slashCommand: this.opts.agentSlashCommandPart ? this.opts.agentSlashCommandPart.command.name : this.opts.commandPart?.slashCommand.command,
+            chatSessionId: getChatSessionIdForTelemetry(this.opts.sessionResource),
+            enableCommandDetection: this.opts.enableCommandDetection,
+            isParticipantDetected: !!detectedAgent,
+            location: this.opts.location,
+            citations: request.response?.codeCitations.length ?? 0,
+            numCodeBlocks: getCodeBlocks(request.response?.response.toString() ?? "").length,
+            attachmentKinds: this.attachmentKindsForTelemetry(request.variableData),
+            model: this.resolveModelId(this.opts.options?.userSelectedModelId),
+            requestStartCopilotSku: this.requestStartCopilotSku,
+            selectedModelSource: this.selectedModelSource,
+            permissionLevel: this.opts.options?.modeInfo?.kind === ChatModeKind.Ask ? undefined : this.opts.options?.modeInfo?.permissionLevel,
+            chatMode: this.opts.options?.modeInfo?.telemetryModeName ?? this.opts.options?.modeInfo?.telemetryModeId,
+            sessionType: getChatSessionTypeForTelemetry(this.opts.sessionResource),
+            harness: isRemoteAgentHostSessionType(getChatSessionType(this.opts.sessionResource)) ? provider : undefined,
+            isAgentHostSession: getIsAgentHostSessionForTelemetry(this.opts.sessionResource),
+            isVirtualWorkspace: this.opts.isVirtualWorkspace,
+            settingDefaultToCopilotHarness: this.opts.settingDefaultToCopilotHarness,
+            settingPreferCopilotHarness: this.opts.settingPreferCopilotHarness,
+            settingLocalAgentEnabled: this.opts.settingLocalAgentEnabled,
+            settingCopilotHarnessIntroductionMode: this.opts.settingCopilotHarnessIntroductionMode
+        });
+    }
+    attachmentKindsForTelemetry(variableData) {
+        return variableData.variables.map(v => {
+            if (v.kind === "implicit") {
+                return "implicit";
+            } else if (v.range) {
+                if (v.kind === "tool") {
+                    return "toolInPrompt";
+                } else if (v.kind === "toolset") {
+                    return "toolsetInPrompt";
+                } else {
+                    return "fileInPrompt";
+                }
+            } else if (v.kind === "command") {
+                return "command";
+            } else if (v.kind === "symbol") {
+                return "symbol";
+            } else if (isImageVariableEntry(v)) {
+                return "image";
+            } else if (v.kind === "directory") {
+                return "directory";
+            } else if (v.kind === "tool") {
+                return "tool";
+            } else if (v.kind === "toolset") {
+                return "toolset";
+            } else {
+                if (URI.isUri(v.value)) {
+                    return "file";
+                } else if (isLocation(v.value)) {
+                    return "location";
+                } else {
+                    return "otherAttachment";
+                }
+            }
+        });
+    }
+    resolveModelId(userSelectedModelId) {
+        return userSelectedModelId && this.languageModelsService.lookupLanguageModel(userSelectedModelId)?.id;
+    }
+};
+ChatRequestTelemetry = ( __decorate([( __param(1, ITelemetryService)), ( __param(2, ILanguageModelsService)), ( __param(3, IChatSessionsService)), ( __param(4, IChatEntitlementService))], ChatRequestTelemetry));
+function getChatSessionTelemetryIds(sessionResource, connectionsService) {
+    const chatSessionId = getChatSessionIdForTelemetry(sessionResource);
+    if (!isAgentHostSessionResource(sessionResource)) {
+        return {
+            chatSessionId
+        };
+    }
+    const identity = connectionsService.resolveSessionResourceIdentity(sessionResource);
+    if (!identity) {
+        return {
+            chatSessionId
+        };
+    }
+    const isProvisionalFallback = !identity.backendSessionIsAdvertised && (isUntitledChatSession(sessionResource) || isUntitledChatSession(identity.backendSession));
+    if (isProvisionalFallback) {
+        return {
+            chatSessionId
+        };
+    }
+    return {
+        chatSessionId,
+        agentSessionId: AgentSession.id(identity.backendSession)
+    };
+}
+function getChatSessionTelemetryContext(sessionResource) {
+    return {
+        chatSessionId: getChatSessionIdForTelemetry(sessionResource),
+        sessionType: getChatSessionTypeForTelemetry(sessionResource),
+        harness: getHarnessForTelemetry(sessionResource)
+    };
+}
+function getChatSessionIdForTelemetry(sessionResource) {
+    const sessionType = getChatSessionType(sessionResource);
+    return isRemoteAgentHostSessionType(sessionType) ? sessionResource.path.slice(1) + (sessionResource.fragment ? `#${sessionResource.fragment}` : "") : chatSessionResourceToId(sessionResource);
+}
+function getChatSessionTypeForTelemetry(sessionResource) {
+    const sessionType = getChatSessionType(sessionResource);
+    return isRemoteAgentHostSessionType(sessionType) ? "remote-agent-host" : sessionType;
+}
+function getIsAgentHostSessionForTelemetry(sessionResource) {
+    return isAgentHostSessionResource(sessionResource);
+}
+function getHarnessForTelemetry(sessionResource) {
+    return parseRemoteAgentHostHarness(getChatSessionType(sessionResource));
+}
+
+export { ChatRequestTelemetry, ChatServiceTelemetry, getChatSessionTelemetryContext, getChatSessionTelemetryIds };