@codingame/monaco-vscode-workbench-service-override 37.6.0 → 38.0.0

package/vscode/src/vs/sessions/contrib/sessions/browser/sessionsLifecycleTracker.js

@@ -0,0 +1,510 @@
+
+import { StringSHA1, hash } from '@codingame/monaco-vscode-api/vscode/vs/base/common/hash';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { Schemas } from '@codingame/monaco-vscode-api/vscode/vs/base/common/network';
+import { StorageScope, StorageTarget } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage';
+import '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
+import { AgentsWindowUsage } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/agentsWindowUsage';
+import { getGitHubPullRequestRefs, SessionArtifactKind } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/session';
+import { getPullRequestStatusFromIcon } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/github/common/types';
+import { linkKey } from '@codingame/monaco-vscode-api/vscode/vs/sessions/common/sessionLinks';
+import { getSessionsTelemetryProviderId, classifySessionWorkspaceTopology, hashSessionIdForTelemetry } from '@codingame/monaco-vscode-api/vscode/vs/sessions/common/sessionsTelemetry';
+
+function getResolvedPullRequestStatus(pullRequest) {
+    const state = pullRequest.liveState ?? pullRequest.state;
+    if (state !== "open") {
+        return state;
+    }
+    return pullRequest.liveState !== undefined && getPullRequestStatusFromIcon(pullRequest.icon) === "draft" ? "draft" : state;
+}
+const SESSIONS_KEY = "agentSessions.telemetry.summary.sessions";
+const WORKSPACE_SESSIONS_KEY = "agentSessions.telemetry.workspaceSessions";
+const PROVIDER_SESSIONS_KEY = "agentSessions.telemetry.providerSessions";
+const MAX_TRACKED_SESSIONS = 2000;
+const MAX_TYPED_FILES_PER_SESSION = 250;
+const TYPED_FILE_HASH_LENGTH = 12;
+function hashTypedFilePath(resource) {
+    const sha1 = ( new StringSHA1());
+    sha1.update(( resource.toString()));
+    return sha1.digest().substring(0, TYPED_FILE_HASH_LENGTH);
+}
+class SessionsLifecycleTracker extends Disposable {
+    constructor(_storageService, appLaunchCount) {
+        super();
+        this._storageService = _storageService;
+        this._usage = ( new AgentsWindowUsage(_storageService));
+        this._appLaunchCount = appLaunchCount;
+        this._stats = this._load();
+    }
+    recordNewChatRequestSent(session) {
+        this._recordRequestSent(session,  true);
+    }
+    recordRequestSent(session) {
+        this._recordRequestSent(session,  false);
+    }
+    _recordRequestSent(session, isNewChat) {
+        const entry = this._ensure(session);
+        entry.requestsSent++;
+        if (isNewChat) {
+            entry.chatCount++;
+        }
+        if (entry.firstRequestSentAt === 0) {
+            entry.firstRequestSentAt = Date.now();
+            entry.firstRequestSentInThisClient = true;
+        }
+        this._updateObservedState(entry, session);
+        this._save();
+    }
+    recordFirstRequestTaskInfo(session, info) {
+        const entry = this._stats.get(session.sessionId);
+        if (!entry || entry.hasWorktreeCreatedTask !== undefined) {
+            return;
+        }
+        entry.hasWorktreeCreatedTask = info.hasWorktreeCreatedTask;
+        entry.configuredTasksCount = info.configuredTasksCount;
+        this._save();
+    }
+    bumpCounter(session, key) {
+        const entry = this._ensure(session);
+        entry[key]++;
+        this._updateObservedState(entry, session);
+        this._save();
+    }
+    addTypedCharacters(sessionId, resource, characters) {
+        const entry = this._stats.get(sessionId);
+        if (!entry || characters <= 0) {
+            return;
+        }
+        entry.typedCharacters = (entry.typedCharacters ?? 0) + characters;
+        const fileHash = hashTypedFilePath(resource);
+        const typedFileHashes = entry.typedFileHashes ?? (entry.typedFileHashes = []);
+        if (typedFileHashes.length < MAX_TYPED_FILES_PER_SESSION && !typedFileHashes.includes(fileHash)) {
+            typedFileHashes.push(fileHash);
+        }
+        this._save();
+    }
+    updateSessionState(session) {
+        const entry = this._stats.get(session.sessionId);
+        if (!entry) {
+            return;
+        }
+        this._updateObservedState(entry, session);
+        this._save();
+    }
+    incrementAndGetUserRequestCounters(session) {
+        const providerId = getSessionsTelemetryProviderId(session.providerId);
+        const workspaceUri = session.workspace.get()?.uri.toString();
+        const userSessionsTotal = this._usage.recordSessionCreated();
+        const providerCounts = this._readProviderCounterMap();
+        const userSessionsForProvider = (providerCounts[providerId] ?? 0) + 1;
+        providerCounts[providerId] = userSessionsForProvider;
+        this._storageService.store(
+            PROVIDER_SESSIONS_KEY,
+            JSON.stringify(providerCounts),
+            StorageScope.APPLICATION,
+            StorageTarget.MACHINE
+        );
+        let userSessionsInWorkspace = 0;
+        if (workspaceUri) {
+            const workspaceCounts = this._readCounterMap(WORKSPACE_SESSIONS_KEY);
+            userSessionsInWorkspace = (workspaceCounts[workspaceUri] ?? 0) + 1;
+            workspaceCounts[workspaceUri] = userSessionsInWorkspace;
+            this._storageService.store(
+                WORKSPACE_SESSIONS_KEY,
+                JSON.stringify(workspaceCounts),
+                StorageScope.APPLICATION,
+                StorageTarget.MACHINE
+            );
+        }
+        return {
+            userSessionsTotal,
+            userSessionsInWorkspace,
+            userSessionsForProvider
+        };
+    }
+    getUserRequestCounters(session) {
+        return this._readUserRequestCounters(session.providerId, session.workspace.get()?.uri.toString());
+    }
+    isTracked(sessionId) {
+        return ( this._stats.has(sessionId));
+    }
+    getTrackedIds() {
+        return [...( this._stats.keys())];
+    }
+    getTrackedEntries() {
+        const result = [];
+        for (const [sessionId, entry] of this._stats) {
+            result.push({
+                sessionId,
+                providerId: entry.providerId
+            });
+        }
+        return result;
+    }
+    finalize(sessionId, reason, finalSession) {
+        const entry = this._stats.get(sessionId);
+        if (!entry) {
+            return undefined;
+        }
+        if (finalSession) {
+            this._updateObservedState(entry, finalSession);
+        }
+        this._stats.delete(sessionId);
+        this._save();
+        return buildSummary(
+            sessionId,
+            entry,
+            reason,
+            this._appLaunchCount,
+            this._readUserRequestCountersForSummary(entry)
+        );
+    }
+    _readUserRequestCountersForSummary(entry) {
+        return this._readUserRequestCounters(entry.providerId, entry.workspaceUriString || undefined);
+    }
+    _readUserRequestCounters(providerId, workspaceUri) {
+        const userSessionsTotal = this._usage.createdSessionCount;
+        const providerCounts = this._readProviderCounterMap();
+        const userSessionsForProvider = providerCounts[getSessionsTelemetryProviderId(providerId)] ?? 0;
+        let userSessionsInWorkspace = 0;
+        if (workspaceUri) {
+            const workspaceCounts = this._readCounterMap(WORKSPACE_SESSIONS_KEY);
+            userSessionsInWorkspace = workspaceCounts[workspaceUri] ?? 0;
+        }
+        return {
+            userSessionsTotal,
+            userSessionsInWorkspace,
+            userSessionsForProvider
+        };
+    }
+    _readProviderCounterMap() {
+        const storedCounts = this._readCounterMap(PROVIDER_SESSIONS_KEY);
+        const providerCounts = {};
+        for (const [providerId, count] of Object.entries(storedCounts)) {
+            const telemetryProviderId = getSessionsTelemetryProviderId(providerId);
+            providerCounts[telemetryProviderId] = (providerCounts[telemetryProviderId] ?? 0) + count;
+        }
+        return providerCounts;
+    }
+    _readCounterMap(key) {
+        const raw = this._storageService.get(key, StorageScope.APPLICATION);
+        if (!raw) {
+            return {};
+        }
+        try {
+            const parsed = JSON.parse(raw);
+            return (parsed && typeof parsed === "object") ? parsed : {};
+        } catch {
+            return {};
+        }
+    }
+    _ensure(session) {
+        const id = session.sessionId;
+        let entry = this._stats.get(id);
+        if (!entry) {
+            if (this._stats.size >= MAX_TRACKED_SESSIONS) {
+                this._evictOldest();
+            }
+            entry = createEntry(session, this._appLaunchCount);
+            this._stats.set(id, entry);
+        }
+        return entry;
+    }
+    _updateObservedState(entry, session) {
+        entry.isExternal = session.isExternal?.get() ?? entry.isExternal ?? false;
+        this._updateWorkspaceTopology(entry, session);
+        this._updatePullRequestState(entry, session);
+        this._updateArtifactCounts(entry, session);
+        this._updateChangesSummary(entry, session);
+    }
+    _updateWorkspaceTopology(entry, session) {
+        const folders = session.workspace.get()?.folders;
+        if (!folders || folders.length === 0) {
+            return;
+        }
+        const topology = classifySessionWorkspaceTopology(
+            folders.length,
+            folders.filter(folder => folder.gitRepository !== undefined).length
+        );
+        entry.isMultiRoot = topology.isMultiRoot;
+        entry.folderCount = topology.folderCount;
+        entry.gitFolderCount = topology.gitFolderCount;
+        entry.nonGitFolderCount = topology.nonGitFolderCount;
+    }
+    _updatePullRequestState(entry, session) {
+        const gitHubInfo = session.workspace.get()?.folders[0]?.gitRepository?.gitHubInfo.get();
+        if (!gitHubInfo) {
+            return;
+        }
+        const pullRequests = gitHubInfo.pullRequests;
+        entry.pullRequestCount = pullRequests?.length ?? (gitHubInfo.pullRequest ? 1 : 0);
+        entry.pullRequestStatus = getPullRequestStatusFromIcon(gitHubInfo.pullRequest?.icon ?? pullRequests?.[0]?.icon);
+    }
+    _updateArtifactCounts(entry, session) {
+        const artifacts = session.artifacts?.get();
+        if (!artifacts) {
+            return;
+        }
+        const pullRequestStatuses = ( new Map());
+        for (const folder of session.workspace.get()?.folders ?? []) {
+            for (const pullRequest of getGitHubPullRequestRefs(folder.gitRepository?.gitHubInfo.get())) {
+                const status = getResolvedPullRequestStatus(pullRequest);
+                if (status) {
+                    pullRequestStatuses.set(linkKey(( pullRequest.uri.toString())), status);
+                }
+            }
+        }
+        let pullRequestArtifactMergedCount = 0;
+        let pullRequestArtifactOpenCount = 0;
+        let pullRequestArtifactDraftCount = 0;
+        let pullRequestArtifactClosedCount = 0;
+        let issueArtifactCount = 0;
+        let otherArtifactCount = 0;
+        let artifactCount = 0;
+        let referenceCount = 0;
+        for (const artifact of artifacts) {
+            if (!artifact.isArtifact) {
+                referenceCount++;
+                continue;
+            }
+            artifactCount++;
+            if (artifact.kind === SessionArtifactKind.Issue) {
+                issueArtifactCount++;
+                continue;
+            }
+            if (artifact.kind !== SessionArtifactKind.PullRequest) {
+                otherArtifactCount++;
+                continue;
+            }
+            const status = artifact.link ? pullRequestStatuses.get(linkKey(( artifact.link.toString()))) : undefined;
+            switch (status) {
+            case "merged":
+                pullRequestArtifactMergedCount++;
+                break;
+            case "open":
+                pullRequestArtifactOpenCount++;
+                break;
+            case "draft":
+                pullRequestArtifactDraftCount++;
+                break;
+            case "closed":
+                pullRequestArtifactClosedCount++;
+                break;
+            }
+        }
+        entry.pullRequestArtifactMergedCount = pullRequestArtifactMergedCount;
+        entry.pullRequestArtifactOpenCount = pullRequestArtifactOpenCount;
+        entry.pullRequestArtifactDraftCount = pullRequestArtifactDraftCount;
+        entry.pullRequestArtifactClosedCount = pullRequestArtifactClosedCount;
+        entry.issueArtifactCount = issueArtifactCount;
+        entry.otherArtifactCount = otherArtifactCount;
+        entry.artifactCount = artifactCount;
+        entry.referenceCount = referenceCount;
+    }
+    _updateChangesSummary(entry, session) {
+        const summary = session.changesSummary?.get();
+        if (summary) {
+            entry.filesChanged = summary.files;
+            entry.linesAdded = summary.additions;
+            entry.linesDeleted = summary.deletions;
+            return;
+        }
+        let files = 0;
+        let additions = 0;
+        let deletions = 0;
+        for (const change of session.mainChat.get().changes.get()) {
+            files++;
+            additions += change.insertions;
+            deletions += change.deletions;
+        }
+        entry.filesChanged = files;
+        entry.linesAdded = additions;
+        entry.linesDeleted = deletions;
+    }
+    _evictOldest() {
+        let oldestId;
+        let oldestTime = Number.POSITIVE_INFINITY;
+        for (const [id, entry] of this._stats) {
+            if (entry.firstObservedAt < oldestTime) {
+                oldestTime = entry.firstObservedAt;
+                oldestId = id;
+            }
+        }
+        if (oldestId !== undefined) {
+            this._stats.delete(oldestId);
+        }
+    }
+    _load() {
+        const raw = this._storageService.get(SESSIONS_KEY, StorageScope.APPLICATION);
+        const map = ( new Map());
+        if (!raw) {
+            return map;
+        }
+        try {
+            const parsed = JSON.parse(raw);
+            if (parsed && typeof parsed === "object") {
+                for (const [id, value] of Object.entries(parsed)) {
+                    if (value && typeof value === "object") {
+                        const entry = value;
+                        if (entry.typedFileHashes?.some(fileHash => typeof fileHash !== "string")) {
+                            entry.typedFileHashes = [];
+                        }
+                        map.set(id, entry);
+                    }
+                }
+            }
+        } catch {}
+        return map;
+    }
+    _save() {
+        if (this._stats.size === 0) {
+            this._storageService.remove(SESSIONS_KEY, StorageScope.APPLICATION);
+            return;
+        }
+        const obj = {};
+        for (const [id, entry] of this._stats) {
+            obj[id] = entry;
+        }
+        this._storageService.store(
+            SESSIONS_KEY,
+            JSON.stringify(obj),
+            StorageScope.APPLICATION,
+            StorageTarget.MACHINE
+        );
+    }
+}
+function createEntry(session, appLaunchCount) {
+    const workspace = session.workspace.get();
+    const workspaceUriString = workspace?.uri.toString() ?? "";
+    const hasWorktree = workspace?.folders.some(folder => folder.gitRepository?.workTreeUri !== undefined) ?? false;
+    const hasGit = workspace?.folders.some(folder => folder.gitRepository !== undefined) ?? false;
+    const isVirtual = workspace ? workspace.uri.scheme !== Schemas.file : false;
+    const folders = workspace?.folders ?? [];
+    const topology = classifySessionWorkspaceTopology(
+        folders.length,
+        folders.filter(folder => folder.gitRepository !== undefined).length
+    );
+    return {
+        providerId: session.providerId,
+        providerType: session.sessionType,
+        sessionResourceUri: ( session.resource.toString()),
+        workspaceUriString,
+        isolationKind: hasWorktree ? "worktree" : "folder",
+        hasGitRepository: hasGit,
+        isVirtualWorkspace: isVirtual,
+        isExternal: session.isExternal?.get() ?? false,
+        isMultiRoot: topology.isMultiRoot,
+        folderCount: topology.folderCount,
+        gitFolderCount: topology.gitFolderCount,
+        nonGitFolderCount: topology.nonGitFolderCount,
+        firstRequestSentInThisClient: false,
+        hasWorktreeCreatedTask: undefined,
+        configuredTasksCount: undefined,
+        firstObservedAt: Date.now(),
+        firstRequestSentAt: 0,
+        appLaunchCountAtFirstObserved: appLaunchCount,
+        requestsSent: 0,
+        chatCount: 0,
+        feedbackAdded: 0,
+        feedbackConverted: 0,
+        feedbackReplyAdded: 0,
+        feedbackSubmitted: 0,
+        createPullRequest: 0,
+        createDraftPullRequest: 0,
+        updatePullRequest: 0,
+        mergePullRequest: 0,
+        checkoutPullRequest: 0,
+        initializeRepository: 0,
+        commit: 0,
+        commitAndSync: 0,
+        sessionRestored: 0,
+        stickinessToggled: 0,
+        maximizeToggled: 0,
+        chatDeleted: 0,
+        chatRenamed: 0,
+        sessionRenamed: 0,
+        fixCIChecks: 0,
+        taskRun: 0,
+        typedCharacters: 0,
+        typedFileHashes: [],
+        filesChanged: 0,
+        linesAdded: 0,
+        linesDeleted: 0,
+        pullRequestCount: 0,
+        pullRequestStatus: undefined,
+        pullRequestArtifactMergedCount: 0,
+        pullRequestArtifactOpenCount: 0,
+        pullRequestArtifactDraftCount: 0,
+        pullRequestArtifactClosedCount: 0,
+        issueArtifactCount: 0,
+        otherArtifactCount: 0,
+        artifactCount: 0,
+        referenceCount: 0
+    };
+}
+function buildSummary(sessionId, entry, reason, appLaunchCount, requestCounters) {
+    const now = Date.now();
+    return {
+        agentSessionId: hashSessionIdForTelemetry(sessionId),
+        providerId: getSessionsTelemetryProviderId(entry.providerId),
+        providerType: entry.providerType,
+        isolationKind: entry.isolationKind,
+        workspaceHash: entry.workspaceUriString ? ( hash(entry.workspaceUriString).toString(16)) : "",
+        hasGitRepository: entry.hasGitRepository,
+        isVirtualWorkspace: entry.isVirtualWorkspace,
+        isExternal: entry.isExternal ?? false,
+        isMultiRoot: entry.isMultiRoot ?? false,
+        folderCount: entry.folderCount ?? 0,
+        gitFolderCount: entry.gitFolderCount ?? 0,
+        nonGitFolderCount: entry.nonGitFolderCount ?? 0,
+        doneReason: reason,
+        firstRequestSentInThisClient: entry.firstRequestSentInThisClient,
+        hasWorktreeCreatedTask: entry.hasWorktreeCreatedTask,
+        configuredTasksCount: entry.configuredTasksCount,
+        timeSinceFirstObservedMs: now - entry.firstObservedAt,
+        timeSinceFirstRequestMs: entry.firstRequestSentAt > 0 ? (now - entry.firstRequestSentAt) : -1,
+        appLaunchesSinceFirstObserved: appLaunchCount - entry.appLaunchCountAtFirstObserved,
+        requestsSent: entry.requestsSent,
+        chatCount: entry.chatCount,
+        feedbackAdded: entry.feedbackAdded,
+        feedbackConverted: entry.feedbackConverted,
+        feedbackReplyAdded: entry.feedbackReplyAdded,
+        feedbackSubmitted: entry.feedbackSubmitted,
+        createPullRequest: entry.createPullRequest,
+        createDraftPullRequest: entry.createDraftPullRequest,
+        updatePullRequest: entry.updatePullRequest,
+        mergePullRequest: entry.mergePullRequest,
+        checkoutPullRequest: entry.checkoutPullRequest,
+        initializeRepository: entry.initializeRepository,
+        commit: entry.commit,
+        commitAndSync: entry.commitAndSync,
+        sessionRestored: entry.sessionRestored,
+        stickinessToggled: entry.stickinessToggled,
+        maximizeToggled: entry.maximizeToggled,
+        chatDeleted: entry.chatDeleted,
+        chatRenamed: entry.chatRenamed,
+        sessionRenamed: entry.sessionRenamed,
+        fixCIChecks: entry.fixCIChecks,
+        taskRun: entry.taskRun,
+        typedCharacters: entry.typedCharacters ?? 0,
+        typedFileCount: entry.typedFileHashes?.length ?? 0,
+        filesChanged: entry.filesChanged,
+        linesAdded: entry.linesAdded,
+        linesDeleted: entry.linesDeleted,
+        pullRequestCount: entry.pullRequestCount ?? 0,
+        pullRequestStatus: entry.pullRequestStatus,
+        pullRequestArtifactMergedCount: entry.pullRequestArtifactMergedCount ?? 0,
+        pullRequestArtifactOpenCount: entry.pullRequestArtifactOpenCount ?? 0,
+        pullRequestArtifactDraftCount: entry.pullRequestArtifactDraftCount ?? 0,
+        pullRequestArtifactClosedCount: entry.pullRequestArtifactClosedCount ?? 0,
+        issueArtifactCount: entry.issueArtifactCount ?? 0,
+        otherArtifactCount: entry.otherArtifactCount ?? 0,
+        artifactCount: entry.artifactCount ?? 0,
+        referenceCount: entry.referenceCount ?? 0,
+        userSessionsTotal: requestCounters.userSessionsTotal,
+        userSessionsInWorkspace: requestCounters.userSessionsInWorkspace,
+        userSessionsForProvider: requestCounters.userSessionsForProvider
+    };
+}
+
+export { MAX_TRACKED_SESSIONS, MAX_TYPED_FILES_PER_SESSION, SESSIONS_KEY, SessionsLifecycleTracker };

package/vscode/src/vs/sessions/contrib/sessions/browser/sessionsTelemetry.contribution.d.ts

@@ -6,6 +6,7 @@ import { IStorageService } from "@codingame/monaco-vscode-api/vscode/vs/platform
 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 { IWorkbenchContribution } from "@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions";
+import { IChatEntitlementService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/chat/common/chatEntitlementService.service";
 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";
@@ -31,18 +32,17 @@ export declare class SessionsTelemetryContribution extends Disposable implements
     private readonly _searchService;
     private readonly _configurationService;
     private readonly _sessionsTasksService;
+    private readonly _chatEntitlementService;
     static readonly ID = "workbench.contrib.sessionsTelemetry";
-    /** Final workspace file counts, keyed by session id (so subsequent log calls for the same session are instant). */
-    private readonly _workspaceFileCountCache;
-    /** Pending workspace file-count fetches, keyed by workspace URI so a prewarm started before a session-id assignment can be picked up after. */
-    private readonly _workspaceFileCountInFlight;
+    /** Pending and completed workspace file counts, keyed by the scanned workspace folders so each is scanned at most once per window. */
+    private readonly _workspaceFileCounts;
     /** Persists per-session lifecycle counters for the `agents/sessionSummary` event. */
     private readonly _lifecycleTracker;
     /** Counts characters the user manually types into session workspace folders from this window. */
     private readonly _typedCharactersTracker;
     /** Listener per provider that waits for the provider's first batch of sessions so we can run a one-time reconciliation against tracked entries. */
     private readonly _providerReconcileListeners;
-    constructor(_sessionsManagementService: ISessionsManagementService, _sessionsService: ISessionsService, _telemetryService: ITelemetryService, _uriIdentityService: IUriIdentityService, _storageService: IStorageService, _searchService: ISearchService, _configurationService: IConfigurationService, commandService: ICommandService, agentFeedbackService: IAgentFeedbackService, sessionsPartService: ISessionsPartService, sessionsProvidersService: ISessionsProvidersService, _sessionsTasksService: ISessionsTasksService, modelService: IModelService, sessionsWindowUsageService: ISessionsWindowUsageService);
+    constructor(_sessionsManagementService: ISessionsManagementService, _sessionsService: ISessionsService, _telemetryService: ITelemetryService, _uriIdentityService: IUriIdentityService, _storageService: IStorageService, _searchService: ISearchService, _configurationService: IConfigurationService, commandService: ICommandService, agentFeedbackService: IAgentFeedbackService, sessionsPartService: ISessionsPartService, sessionsProvidersService: ISessionsProvidersService, _sessionsTasksService: ISessionsTasksService, modelService: IModelService, sessionsWindowUsageService: ISessionsWindowUsageService, _chatEntitlementService: IChatEntitlementService);
     /**
      * Resolves the session a session-scoped command was invoked on. The first
      * argument is expected to be either a session resource {@link URI} or a
@@ -118,8 +118,7 @@ export declare class SessionsTelemetryContribution extends Disposable implements
     private _getChatFields;
     private _getWorkspaceFields;
     private _getWorkspaceTopologyFields;
-    private _getOrFetchWorkspaceFileCount;
-    private _startWorkspaceFileCountFetch;
+    private _getWorkspaceFileCount;
     private _computeWorkspaceFileCount;
     private _getRequestFields;
     private _getAllSessionsFields;