@codingame/monaco-vscode-workbench-service-override 37.2.0 → 37.3.1

package/vscode/src/vs/sessions/contrib/sessions/browser/sessionsTelemetry.contribution.js

@@ -0,0 +1,724 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { disposableTimeout } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { hash } from '@codingame/monaco-vscode-api/vscode/vs/base/common/hash';
+import { Disposable, DisposableMap } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { Schemas } from '@codingame/monaco-vscode-api/vscode/vs/base/common/network';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { IModelService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/model.service';
+import { ICommandService } from '@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands.service';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { IStorageService } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service';
+import { ITelemetryService } from '@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service';
+import { IUriIdentityService } from '@codingame/monaco-vscode-api/vscode/vs/platform/uriIdentity/common/uriIdentity.service';
+import { isImageVariableEntry, isChatRequestFileEntry } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/attachments/chatVariableEntries';
+import { getExcludes, QueryType } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/search/common/search';
+import { ISearchService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/search/common/search.service';
+import { IAgentFeedbackService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/agentFeedback/browser/agentFeedbackService.service';
+import { ISessionsTasksService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/chat/browser/sessionsTasksService.service';
+import { SessionStatus } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/session';
+import { ISessionsManagementService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/sessionsManagement.service';
+import { ISessionsService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsService.service';
+import { ISessionsProvidersService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsProvidersService.service';
+import { getSessionsTelemetryProviderId, hashSessionIdForTelemetry, classifySessionWorkspaceTopology } from '@codingame/monaco-vscode-api/vscode/vs/sessions/common/sessionsTelemetry';
+import { ISessionsPartService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsPartService.service';
+import { ISessionsWindowUsageService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsWindowUsageService.service';
+import { SessionsLifecycleTracker } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/sessions/browser/sessionsLifecycleTracker';
+import { SessionsTypedCharactersTracker } from './sessionsTypedCharactersTracker.js';
+
+let SessionsTelemetryContribution = class SessionsTelemetryContribution extends Disposable {
+    static {
+        this.ID = "workbench.contrib.sessionsTelemetry";
+    }
+    constructor(
+        _sessionsManagementService,
+        _sessionsService,
+        _telemetryService,
+        _uriIdentityService,
+        _storageService,
+        _searchService,
+        _configurationService,
+        commandService,
+        agentFeedbackService,
+        sessionsPartService,
+        sessionsProvidersService,
+        _sessionsTasksService,
+        modelService,
+        sessionsWindowUsageService
+    ) {
+        super();
+        this._sessionsManagementService = _sessionsManagementService;
+        this._sessionsService = _sessionsService;
+        this._telemetryService = _telemetryService;
+        this._uriIdentityService = _uriIdentityService;
+        this._storageService = _storageService;
+        this._searchService = _searchService;
+        this._configurationService = _configurationService;
+        this._sessionsTasksService = _sessionsTasksService;
+        this._workspaceFileCountCache = ( new Map());
+        this._workspaceFileCountInFlight = ( new Map());
+        this._providerReconcileListeners = this._register(( new DisposableMap()));
+        this._lifecycleTracker = ( new SessionsLifecycleTracker(this._storageService, sessionsWindowUsageService.windowOpenCount));
+        this._typedCharactersTracker = this._register(( new SessionsTypedCharactersTracker(
+            () => this._sessionsService.activeSession.get(),
+            entries => this._recordTypedCharacters(entries),
+            modelService
+        )));
+        this._register(this._lifecycleTracker);
+        this._register(
+            this._storageService.onWillSaveState(() => this._typedCharactersTracker.flush())
+        );
+        this._register(this._sessionsManagementService.onWillSendRequest(session => {
+            this._startWorkspaceFileCountFetch(session.workspace.get());
+        }));
+        this._register(
+            this._sessionsManagementService.onDidSendRequest(e => this._logRequestSent(e))
+        );
+        this._register(
+            this._sessionsManagementService.onDidArchiveSession(session => this._logSessionArchived(session))
+        );
+        this._register(
+            this._sessionsManagementService.onDidUnarchiveSession(session => this._logSessionUnarchived(session))
+        );
+        this._register(
+            this._sessionsManagementService.onDidDeleteSession(session => this._logSessionDeleted(session))
+        );
+        this._register(
+            this._sessionsManagementService.onDidDeleteChat(session => this._logChatDeleted(session))
+        );
+        this._register(
+            this._sessionsManagementService.onDidRenameChat(session => this._logChatRenamed(session))
+        );
+        this._register(
+            this._sessionsManagementService.onDidRenameSession(session => this._logSessionRenamed(session))
+        );
+        this._register(
+            this._sessionsService.onDidToggleSessionStickiness(e => this._logSessionStickinessToggled(e.session, e.sticky))
+        );
+        this._register(
+            sessionsPartService.onDidToggleMaximizeSession(e => this._logSessionMaximizeToggled(e.session, e.maximized))
+        );
+        this._register(
+            this._sessionsManagementService.onDidChangeSessions(e => this._onDidChangeSessions(e))
+        );
+        for (const provider of sessionsProvidersService.getProviders()) {
+            this._trackProviderForReconciliation(provider);
+        }
+        this._register(sessionsProvidersService.onDidChangeProviders(e => {
+            for (const provider of e.added) {
+                this._trackProviderForReconciliation(provider);
+            }
+            for (const provider of e.removed) {
+                this._providerReconcileListeners.deleteAndDispose(provider.id);
+            }
+        }));
+        this._register(commandService.onDidExecuteCommand(e => {
+            let log;
+            switch (e.commandId) {
+            case "github.copilot.chat.createPullRequestCopilotCLIAgentSession.createPR":
+            case "workbench.action.agentSessions.runSkill.createPR":
+                log = session => this._logCreatePullRequest(session);
+                break;
+            case "workbench.action.agentSessions.runSkill.createDraftPR":
+                log = session => this._logCreateDraftPullRequest(session);
+                break;
+            case "workbench.action.agentSessions.runSkill.updatePR":
+                log = session => this._logUpdatePullRequest(session);
+                break;
+            case "github.copilot.chat.mergeCopilotCLIAgentSessionChanges.merge":
+            case "workbench.action.agentSessions.runSkill.merge":
+                log = session => this._logMergePullRequest(session);
+                break;
+            case "github.copilot.chat.checkoutPullRequestReroute":
+            case "pr.checkoutFromChat":
+                log = session => this._logCheckoutPullRequest(session);
+                break;
+            case "github.copilot.sessions.initializeRepository":
+                log = session => this._logInitializeRepository(session);
+                break;
+            case "github.copilot.sessions.commit":
+                log = session => this._logCommit(session);
+                break;
+            case "github.copilot.sessions.commitAndSync":
+                log = session => this._logCommitAndSync(session);
+                break;
+            case "agentSession.restore":
+                log = session => this._logSessionRestored(session);
+                break;
+            case "sessions.action.fixCIChecks":
+                log = session => this._logFixCIChecks(session);
+                break;
+            default:
+                return;
+            }
+            const session = this._getSessionFromCommandArgs(e.args);
+            if (session) {
+                log(session);
+            }
+        }));
+        this._register(agentFeedbackService.onDidAddFeedback(e => this._logFeedbackAdded(e)));
+        this._register(
+            agentFeedbackService.onDidConvertFeedback(e => this._logFeedbackConverted(e))
+        );
+        this._register(agentFeedbackService.onDidAddReply(e => this._logFeedbackReplyAdded(e)));
+        this._register(
+            agentFeedbackService.onDidSubmitFeedback(e => this._logFeedbackSubmitted(e))
+        );
+        this._register(
+            this._sessionsTasksService.onDidRunTask(e => this._lifecycleTracker.bumpCounter(e.session, "taskRun"))
+        );
+    }
+    _getSessionFromCommandArgs(args) {
+        const first = args[0];
+        let resource;
+        if (URI.isUri(first)) {
+            resource = first;
+        } else if (first && typeof first === "object" && URI.isUri(first.resource)) {
+            resource = first.resource;
+        }
+        return resource ? this._sessionsManagementService.getSession(resource) : undefined;
+    }
+    _logRequestSent(e) {
+        const {
+            session,
+            chat,
+            isNewSession,
+            isNewChat,
+            options
+        } = e;
+        if (isNewChat) {
+            const wasTracked = this._lifecycleTracker.isTracked(session.sessionId);
+            this._lifecycleTracker.recordNewChatRequestSent(session);
+            if (!wasTracked) {
+                void this._sessionsTasksService.getAllTasks(session).then(tasks => {
+                    const hasWorktreeCreatedTask = ( tasks.some(t => t.task.runOptions?.runOn === "worktreeCreated"));
+                    this._lifecycleTracker.recordFirstRequestTaskInfo(session, {
+                        hasWorktreeCreatedTask,
+                        configuredTasksCount: tasks.length
+                    });
+                });
+            }
+        } else {
+            this._lifecycleTracker.recordRequestSent(session);
+        }
+        const allSessions = this._sessionsManagementService.getSessions();
+        const visibleSessionsCount = this._sessionsService.visibleSessions.get().filter(s => s !== undefined).length;
+        const workspace = session.workspace.get();
+        const requestCounters = isNewSession ? this._lifecycleTracker.incrementAndGetUserRequestCounters(session) : this._lifecycleTracker.getUserRequestCounters(session);
+        const sync = {
+            isNewSession,
+            isNewChat,
+            visibleSessionsCount,
+            ...this._getRequestFields(options),
+            ...this._getSessionFields(session),
+            ...this._getChatFields(chat),
+            ...this._getAllSessionsFields(session, allSessions),
+            ...requestCounters
+        };
+        void this._getOrFetchWorkspaceFileCount(session.sessionId, workspace).then(workspaceFileCount => {
+            this._telemetryService.publicLog2("agents/requestSent", {
+                ...sync,
+                ...this._getWorkspaceFields(workspace, workspaceFileCount),
+                ...this._getWorkspaceTopologyFields(workspace)
+            });
+        });
+    }
+    _logSessionArchived(session) {
+        void this._getSessionActionPayload(session).then(payload => {
+            this._telemetryService.publicLog2("agents/sessionArchived", payload);
+        });
+        this._fireSessionSummary(session, "archived");
+    }
+    _logSessionUnarchived(session) {
+        void this._getSessionActionPayload(session).then(payload => {
+            this._telemetryService.publicLog2("agents/sessionUnarchived", payload);
+        });
+    }
+    _logSessionDeleted(session) {
+        void this._getSessionActionPayload(session).then(payload => {
+            this._telemetryService.publicLog2("agents/sessionDeleted", payload);
+        });
+        this._fireSessionSummary(session, "deleted");
+    }
+    _logChatDeleted(session) {
+        this._lifecycleTracker.bumpCounter(session, "chatDeleted");
+        void this._getSessionActionPayload(session).then(payload => {
+            this._telemetryService.publicLog2("agents/chatDeleted", payload);
+        });
+    }
+    _logChatRenamed(session) {
+        this._lifecycleTracker.bumpCounter(session, "chatRenamed");
+        void this._getSessionActionPayload(session).then(payload => {
+            this._telemetryService.publicLog2("agents/chatRenamed", payload);
+        });
+    }
+    _logSessionRenamed(session) {
+        this._lifecycleTracker.bumpCounter(session, "sessionRenamed");
+        void this._getSessionActionPayload(session).then(payload => {
+            this._telemetryService.publicLog2("agents/sessionRenamed", payload);
+        });
+    }
+    _logSessionStickinessToggled(session, sticky) {
+        this._lifecycleTracker.bumpCounter(session, "stickinessToggled");
+        void this._getSessionActionPayload(session).then(payload => {
+            this._telemetryService.publicLog2("agents/sessionStickinessToggled", {
+                ...payload,
+                sticky
+            });
+        });
+    }
+    _logSessionMaximizeToggled(session, maximized) {
+        this._lifecycleTracker.bumpCounter(session, "maximizeToggled");
+        void this._getSessionActionPayload(session).then(payload => {
+            this._telemetryService.publicLog2("agents/sessionMaximizeToggled", {
+                ...payload,
+                maximized
+            });
+        });
+    }
+    _logCreatePullRequest(session) {
+        this._lifecycleTracker.bumpCounter(session, "createPullRequest");
+        void this._getSessionActionPayload(session).then(payload => {
+            this._telemetryService.publicLog2("agents/createPullRequest", payload);
+        });
+    }
+    _logCreateDraftPullRequest(session) {
+        this._lifecycleTracker.bumpCounter(session, "createDraftPullRequest");
+        void this._getSessionActionPayload(session).then(payload => {
+            this._telemetryService.publicLog2("agents/createDraftPullRequest", payload);
+        });
+    }
+    _logUpdatePullRequest(session) {
+        this._lifecycleTracker.bumpCounter(session, "updatePullRequest");
+        void this._getSessionActionPayload(session).then(payload => {
+            this._telemetryService.publicLog2("agents/updatePullRequest", payload);
+        });
+    }
+    _logMergePullRequest(session) {
+        this._lifecycleTracker.bumpCounter(session, "mergePullRequest");
+        void this._getSessionActionPayload(session).then(payload => {
+            this._telemetryService.publicLog2("agents/mergePullRequest", payload);
+        });
+    }
+    _logCheckoutPullRequest(session) {
+        this._lifecycleTracker.bumpCounter(session, "checkoutPullRequest");
+        void this._getSessionActionPayload(session).then(payload => {
+            this._telemetryService.publicLog2("agents/checkoutPullRequest", payload);
+        });
+    }
+    _logInitializeRepository(session) {
+        this._lifecycleTracker.bumpCounter(session, "initializeRepository");
+        void this._getSessionActionPayload(session).then(payload => {
+            this._telemetryService.publicLog2("agents/initializeRepository", payload);
+        });
+    }
+    _logCommit(session) {
+        this._lifecycleTracker.bumpCounter(session, "commit");
+        void this._getSessionActionPayload(session).then(payload => {
+            this._telemetryService.publicLog2("agents/commit", payload);
+        });
+    }
+    _logCommitAndSync(session) {
+        this._lifecycleTracker.bumpCounter(session, "commitAndSync");
+        void this._getSessionActionPayload(session).then(payload => {
+            this._telemetryService.publicLog2("agents/commitAndSync", payload);
+        });
+    }
+    _logSessionRestored(session) {
+        this._lifecycleTracker.bumpCounter(session, "sessionRestored");
+        void this._getSessionActionPayload(session).then(payload => {
+            this._telemetryService.publicLog2("agents/sessionRestored", payload);
+        });
+    }
+    _logFixCIChecks(session) {
+        this._lifecycleTracker.bumpCounter(session, "fixCIChecks");
+        void this._getSessionActionPayload(session).then(payload => {
+            this._telemetryService.publicLog2("agents/fixCIChecks", payload);
+        });
+    }
+    _logFeedbackAdded(e) {
+        const session = this._sessionsManagementService.getSession(e.sessionResource);
+        if (!session) {
+            return;
+        }
+        this._lifecycleTracker.bumpCounter(session, "feedbackAdded");
+        const hasSuggestion = !!e.feedback.suggestion;
+        const hasExistingFeedbackForFile = e.hasExistingFeedbackForFile;
+        void this._getSessionActionPayload(session).then(payload => {
+            this._telemetryService.publicLog2("agents/feedbackAdded", {
+                ...payload,
+                hasSuggestion,
+                hasExistingFeedbackForFile
+            });
+        });
+    }
+    _logFeedbackConverted(e) {
+        const session = this._sessionsManagementService.getSession(e.sessionResource);
+        if (!session) {
+            return;
+        }
+        this._lifecycleTracker.bumpCounter(session, "feedbackConverted");
+        const feedbackKind = e.kind;
+        const hasSuggestion = !!e.feedback.suggestion;
+        const hasExistingFeedbackForFile = e.hasExistingFeedbackForFile;
+        void this._getSessionActionPayload(session).then(payload => {
+            this._telemetryService.publicLog2("agents/feedbackConverted", {
+                ...payload,
+                feedbackKind,
+                hasSuggestion,
+                hasExistingFeedbackForFile
+            });
+        });
+    }
+    _logFeedbackReplyAdded(e) {
+        const session = this._sessionsManagementService.getSession(e.sessionResource);
+        if (!session) {
+            return;
+        }
+        this._lifecycleTracker.bumpCounter(session, "feedbackReplyAdded");
+        const feedbackKind = e.feedback.kind;
+        const replyCount = e.replyCount;
+        void this._getSessionActionPayload(session).then(payload => {
+            this._telemetryService.publicLog2("agents/feedbackReplyAdded", {
+                ...payload,
+                feedbackKind,
+                replyCount
+            });
+        });
+    }
+    _logFeedbackSubmitted(e) {
+        const session = this._sessionsManagementService.getSession(e.sessionResource);
+        if (!session) {
+            return;
+        }
+        this._lifecycleTracker.bumpCounter(session, "feedbackSubmitted");
+        const {
+            totalCount,
+            userCount,
+            codeReviewCount,
+            prReviewCount,
+            replyCount
+        } = e;
+        void this._getSessionActionPayload(session).then(payload => {
+            this._telemetryService.publicLog2("agents/feedbackSubmitted", {
+                ...payload,
+                totalCount,
+                userCount,
+                codeReviewCount,
+                prReviewCount,
+                replyCount
+            });
+        });
+    }
+    _onDidChangeSessions(e) {
+        for (const session of e.removed) {
+            if (!this._lifecycleTracker.isTracked(session.sessionId)) {
+                continue;
+            }
+            this._register(disposableTimeout(() => {
+                this._fireSessionSummary(session, "deletedRemotely");
+            }, 100));
+        }
+        for (const session of e.changed) {
+            if (!this._lifecycleTracker.isTracked(session.sessionId)) {
+                continue;
+            }
+            if (session.isArchived.get()) {
+                this._register(disposableTimeout(() => {
+                    this._fireSessionSummary(session, "archivedRemotely");
+                }, 100));
+            } else {
+                this._lifecycleTracker.updateSessionState(session);
+            }
+        }
+    }
+    _trackProviderForReconciliation(provider) {
+        if (this._tryReconcileProvider(provider)) {
+            return;
+        }
+        this._providerReconcileListeners.set(provider.id, provider.onDidChangeSessions(() => {
+            if (this._tryReconcileProvider(provider)) {
+                this._providerReconcileListeners.deleteAndDispose(provider.id);
+            }
+        }));
+    }
+    _tryReconcileProvider(provider) {
+        const sessions = provider.getSessions();
+        if (sessions.length === 0) {
+            return false;
+        }
+        const trackedForProvider = this._lifecycleTracker.getTrackedEntries().filter(e => e.providerId === provider.id);
+        if (trackedForProvider.length === 0) {
+            return true;
+        }
+        this._typedCharactersTracker.flush();
+        const liveById = ( new Map());
+        for (const session of sessions) {
+            liveById.set(session.sessionId, session);
+        }
+        for (const {
+            sessionId
+        } of trackedForProvider) {
+            const live = liveById.get(sessionId);
+            if (!live) {
+                const summary = this._lifecycleTracker.finalize(sessionId, "deletedRemotely");
+                if (summary) {
+                    this._logSessionSummary(summary);
+                }
+            } else if (live.isArchived.get()) {
+                this._fireSessionSummary(live, "archivedRemotely");
+            }
+        }
+        return true;
+    }
+    _fireSessionSummary(session, reason) {
+        this._typedCharactersTracker.flush();
+        const summary = this._lifecycleTracker.finalize(session.sessionId, reason, session);
+        if (summary) {
+            this._logSessionSummary(summary);
+        }
+    }
+    _logSessionSummary(summary) {
+        this._telemetryService.publicLog2("agents/sessionSummary", summary);
+    }
+    _recordTypedCharacters(entries) {
+        const deferred = [];
+        for (const entry of entries) {
+            const {
+                session,
+                resource,
+                characters
+            } = entry;
+            const folders = session.workspace.get()?.folders;
+            if (!folders?.length) {
+                if (!session.isQuickChat?.get()) {
+                    deferred.push(entry);
+                }
+                continue;
+            }
+            if (( folders.some(
+                folder => this._uriIdentityService.extUri.isEqualOrParent(resource, folder.workingDirectory)
+            ))) {
+                this._lifecycleTracker.addTypedCharacters(session.sessionId, resource, characters);
+            }
+        }
+        return deferred;
+    }
+    _getSessionActionPayload(session) {
+        const workspace = session.workspace.get();
+        const sessionFields = this._getSessionFields(session);
+        const changesFields = this._getSessionChangesFields(session);
+        return this._getOrFetchWorkspaceFileCount(session.sessionId, workspace).then(workspaceFileCount => ({
+            ...sessionFields,
+            ...this._getWorkspaceFields(workspace, workspaceFileCount),
+            ...changesFields
+        }));
+    }
+    _getSessionFields(session) {
+        return {
+            agentSessionId: hashSessionIdForTelemetry(session.sessionId),
+            providerId: getSessionsTelemetryProviderId(session.providerId),
+            providerType: session.sessionType,
+            chatCount: session.chats.get().length,
+            isExternal: session.isExternal?.get() ?? false
+        };
+    }
+    _getSessionChangesFields(session) {
+        const summary = session.changesSummary?.get();
+        if (summary) {
+            return {
+                sessionFilesChanged: summary.files,
+                sessionLinesAdded: summary.additions,
+                sessionLinesDeleted: summary.deletions
+            };
+        }
+        let sessionFilesChanged = 0;
+        let sessionLinesAdded = 0;
+        let sessionLinesDeleted = 0;
+        for (const change of session.changes.get()) {
+            sessionFilesChanged++;
+            sessionLinesAdded += change.insertions;
+            sessionLinesDeleted += change.deletions;
+        }
+        return {
+            sessionFilesChanged,
+            sessionLinesAdded,
+            sessionLinesDeleted
+        };
+    }
+    _getChatFields(chat) {
+        return {
+            chatModeKind: chat.mode.get()?.kind ?? ""
+        };
+    }
+    _getWorkspaceFields(workspace, workspaceFileCount) {
+        if (!workspace) {
+            return {
+                isolationKind: "folder",
+                workspaceHash: "",
+                hasGitRepository: false,
+                isVirtualWorkspace: false,
+                workspaceFileCount
+            };
+        }
+        const hasWorktree = ( workspace.folders.some(folder => folder.gitRepository?.workTreeUri !== undefined));
+        return {
+            isolationKind: hasWorktree ? "worktree" : "folder",
+            workspaceHash: ( hash(( workspace.uri.toString())).toString(16)),
+            hasGitRepository: ( workspace.folders.some(folder => folder.gitRepository !== undefined)),
+            isVirtualWorkspace: workspace.uri.scheme !== Schemas.file,
+            workspaceFileCount
+        };
+    }
+    _getWorkspaceTopologyFields(workspace) {
+        const folders = workspace?.folders ?? [];
+        const gitFolderCount = folders.filter(folder => folder.gitRepository !== undefined).length;
+        const {
+            isMultiRoot,
+            folderCount,
+            nonGitFolderCount
+        } = classifySessionWorkspaceTopology(folders.length, gitFolderCount);
+        return {
+            isMultiRoot,
+            folderCount,
+            gitFolderCount,
+            nonGitFolderCount
+        };
+    }
+    _getOrFetchWorkspaceFileCount(sessionId, workspace) {
+        const cached = this._workspaceFileCountCache.get(sessionId);
+        if (cached !== undefined) {
+            return Promise.resolve(cached);
+        }
+        const pending = this._startWorkspaceFileCountFetch(workspace);
+        if (!pending) {
+            return Promise.resolve(-1);
+        }
+        return pending.then(count => {
+            this._workspaceFileCountCache.set(sessionId, count);
+            return count;
+        });
+    }
+    _startWorkspaceFileCountFetch(workspace) {
+        if (!workspace || workspace.folders.length === 0) {
+            return undefined;
+        }
+        const workspaceKey = ( workspace.uri.toString());
+        let pending = this._workspaceFileCountInFlight.get(workspaceKey);
+        if (!pending) {
+            pending = this._computeWorkspaceFileCount(workspace).then(count => {
+                this._workspaceFileCountInFlight.delete(workspaceKey);
+                return count;
+            }, () => {
+                this._workspaceFileCountInFlight.delete(workspaceKey);
+                return -1;
+            });
+            this._workspaceFileCountInFlight.set(workspaceKey, pending);
+        }
+        return pending;
+    }
+    async _computeWorkspaceFileCount(workspace) {
+        const excludePattern = getExcludes(this._configurationService.getValue({
+            resource: workspace.uri
+        }));
+        const result = await this._searchService.fileSearch({
+            folderQueries: workspace.folders.map(folder => ({
+                folder: folder.root,
+                disregardIgnoreFiles: false
+            })),
+            type: QueryType.File,
+            filePattern: "",
+            excludePattern
+        });
+        return result.results.length;
+    }
+    _getRequestFields(options) {
+        const attachments = options.attachedContext ?? [];
+        return {
+            queryLength: options.query?.length ?? 0,
+            totalAttachementCount: attachments.length,
+            fileAttachmentCount: attachments.filter(isChatRequestFileEntry).length,
+            imageAttachmentCount: attachments.filter(isImageVariableEntry).length,
+            attachmentKinds: JSON.stringify(countAttachmentsByKind(attachments))
+        };
+    }
+    _getAllSessionsFields(anchorSession, allSessions) {
+        const anchorWorkspaceUri = anchorSession.workspace.get()?.uri;
+        const isSameWorkspace = other => {
+            if (!anchorWorkspaceUri) {
+                return false;
+            }
+            const otherWorkspaceUri = other.workspace.get()?.uri;
+            return otherWorkspaceUri !== undefined && this._uriIdentityService.extUri.isEqual(anchorWorkspaceUri, otherWorkspaceUri);
+        };
+        const inCurrentWorkspaceFolderOnly = [];
+        const inCurrentWorkspace = [];
+        const inAll = [];
+        for (const session of allSessions) {
+            if (session.sessionId === anchorSession.sessionId) {
+                continue;
+            }
+            if (session.isArchived.get()) {
+                continue;
+            }
+            inAll.push(session);
+            if (isSameWorkspace(session)) {
+                inCurrentWorkspace.push(session);
+                const hasWorktree = session.workspace.get()?.folders.some(folder => folder.gitRepository?.workTreeUri !== undefined) ?? false;
+                if (!hasWorktree) {
+                    inCurrentWorkspaceFolderOnly.push(session);
+                }
+            }
+        }
+        const folderOnly = countByStatus(inCurrentWorkspaceFolderOnly);
+        const currentWorkspace = countByStatus(inCurrentWorkspace);
+        const all = countByStatus(inAll);
+        return {
+            currentWorkspaceFolderInProgress: folderOnly.inProgress,
+            currentWorkspaceFolderUnread: folderOnly.unread,
+            currentWorkspaceFolderWaitingForInput: folderOnly.waitingForInput,
+            currentWorkspaceFolderNotDone: folderOnly.notDone,
+            currentWorkspaceInProgress: currentWorkspace.inProgress,
+            currentWorkspaceUnread: currentWorkspace.unread,
+            currentWorkspaceWaitingForInput: currentWorkspace.waitingForInput,
+            currentWorkspaceNotDone: currentWorkspace.notDone,
+            allWorkspacesInProgress: all.inProgress,
+            allWorkspacesUnread: all.unread,
+            allWorkspacesWaitingForInput: all.waitingForInput,
+            allWorkspacesNotDone: all.notDone
+        };
+    }
+};
+SessionsTelemetryContribution = ( __decorate([( __param(0, ISessionsManagementService)), ( __param(1, ISessionsService)), ( __param(2, ITelemetryService)), ( __param(3, IUriIdentityService)), ( __param(4, IStorageService)), ( __param(5, ISearchService)), ( __param(6, IConfigurationService)), ( __param(7, ICommandService)), ( __param(8, IAgentFeedbackService)), ( __param(9, ISessionsPartService)), ( __param(10, ISessionsProvidersService)), ( __param(11, ISessionsTasksService)), ( __param(12, IModelService)), ( __param(13, ISessionsWindowUsageService))], SessionsTelemetryContribution));
+function countByStatus(sessions) {
+    let inProgress = 0;
+    let unread = 0;
+    let waitingForInput = 0;
+    for (const session of sessions) {
+        const status = session.status.get();
+        if (status === SessionStatus.InProgress) {
+            inProgress++;
+        }
+        if (status === SessionStatus.NeedsInput) {
+            waitingForInput++;
+        }
+        if (!session.isRead.get()) {
+            unread++;
+        }
+    }
+    return {
+        inProgress,
+        unread,
+        waitingForInput,
+        notDone: sessions.length
+    };
+}
+function countAttachmentsByKind(attachments) {
+    const counts = {};
+    for (const attachment of attachments) {
+        counts[attachment.kind] = (counts[attachment.kind] ?? 0) + 1;
+    }
+    return counts;
+}
+
+export { SessionsTelemetryContribution };