@codingame/monaco-vscode-api 37.6.1 → 38.0.0

package/vscode/src/vs/sessions/contrib/sessionInputBanners/browser/sessionWorktreeCleanupService.js

@@ -0,0 +1,417 @@
+
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { status } from '../../../../base/browser/ui/aria/aria.js';
+import { RunOnceScheduler, Limiter, raceTimeout, raceCancellationError } from '../../../../base/common/async.js';
+import { CancellationToken, CancellationTokenSource } from '../../../../base/common/cancellation.js';
+import { Disposable } from '../../../../base/common/lifecycle.js';
+import '../../../../base/common/observableInternal/index.js';
+import { ICommandService } from '../../../../platform/commands/common/commands.service.js';
+import { ConfigurationTarget } from '../../../../platform/configuration/common/configuration.js';
+import { IConfigurationService } from '../../../../platform/configuration/common/configuration.service.js';
+import { ByteSize } from '../../../../platform/files/common/files.js';
+import { ILogService } from '../../../../platform/log/common/log.service.js';
+import { ProgressLocation } from '../../../../platform/progress/common/progress.js';
+import { IProgressService } from '../../../../platform/progress/common/progress.service.js';
+import { IDialogService } from '../../../../platform/dialogs/common/dialogs.service.js';
+import { localize } from '../../../../nls.js';
+import { ISessionsListModelService } from '../../../services/sessions/browser/sessionsListModelService.service.js';
+import { ISessionsService } from '../../../services/sessions/browser/sessionsService.service.js';
+import { SessionStatus } from '../../../services/sessions/common/session.js';
+import { ISessionsManagementService } from '../../../services/sessions/common/sessionsManagement.service.js';
+import { observableValue } from '../../../../base/common/observableInternal/observables/observableValue.js';
+
+const CLEANUP_THRESHOLD_BYTES = 5 * ByteSize.GB;
+const CLEANUP_THRESHOLD_WORKTREES = 20;
+const DEFAULT_MINIMUM_SESSION_AGE_DAYS = 15;
+const DAY_MS = 24 * 60 * 60 * 1000;
+const SCAN_CACHE_DURATION_MS = 60 * 60 * 1000;
+const WORKTREE_MEASUREMENT_TIMEOUT_MS = 10_000;
+const AGENT_SESSIONS_STORAGE_CLEANUP_SUGGESTION_SETTING = "chat.agentSessions.sessionStorageCleanupSuggestion.enabled";
+const LEGACY_AGENT_SESSIONS_WORKTREE_LIMIT_PROMPT_SETTING = "sessions.chat.experimental.worktreeLimitPrompt";
+const MANAGE_AGENT_SESSION_WORKTREES_COMMAND_ID = "sessions.chat.manageAgentSessionWorktrees";
+let SessionWorktreeCleanupService = class SessionWorktreeCleanupService extends Disposable {
+    constructor(
+        sessionsManagementService,
+        sessionsService,
+        sessionsListModelService,
+        dialogService,
+        logService,
+        configurationService,
+        progressService,
+        commandService
+    ) {
+        super();
+        this.sessionsManagementService = sessionsManagementService;
+        this.sessionsService = sessionsService;
+        this.sessionsListModelService = sessionsListModelService;
+        this.dialogService = dialogService;
+        this.logService = logService;
+        this.configurationService = configurationService;
+        this.progressService = progressService;
+        this.commandService = commandService;
+        this._lastScanAt = 0;
+        this._lastMeasurementAt = 0;
+        this._lastMeasuredSessionSignature = "";
+        this._activated = false;
+        this._dismissed = false;
+        this._suggestion = observableValue(this, undefined);
+        this.suggestion = this._suggestion;
+        this._register(this.configurationService.onDidChangeConfiguration(event => {
+            if (!event.affectsConfiguration(AGENT_SESSIONS_STORAGE_CLEANUP_SUGGESTION_SETTING)) {
+                return;
+            }
+            this._lastScanAt = 0;
+            if (!this._isEnabled()) {
+                this._suggestion.set(undefined, undefined);
+                return;
+            }
+            if (this._activated) {
+                void this._refreshIfNeeded().catch(
+                    error => this.logService.warn("[SessionWorktreeCleanupService] Failed to refresh worktree usage", error)
+                );
+            }
+        }));
+        this._register(this.sessionsManagementService.onDidArchiveSession(() => {
+            this._lastScanAt = 0;
+            this._lastMeasurementAt = 0;
+        }));
+        const refreshScheduler = this._register(( new RunOnceScheduler(() => {
+            if (this._activated) {
+                void this._refreshIfNeeded().catch(
+                    error => this.logService.warn("[SessionWorktreeCleanupService] Failed to refresh worktree usage", error)
+                );
+            }
+        }, 10_000)));
+        this._register(this.sessionsManagementService.onDidChangeSessions(() => {
+            this._lastScanAt = 0;
+            refreshScheduler.schedule();
+        }));
+    }
+    activate() {
+        this._activated = true;
+        return this._refreshIfNeeded();
+    }
+    refresh() {
+        this._activated = true;
+        this._lastScanAt = 0;
+        return this._refreshIfNeeded();
+    }
+    _refreshIfNeeded() {
+        if (!this._isEnabled()) {
+            return Promise.resolve();
+        }
+        if (this._refreshPromise) {
+            return this._refreshPromise;
+        }
+        if (Date.now() - this._lastScanAt < SCAN_CACHE_DURATION_MS) {
+            return Promise.resolve();
+        }
+        const refresh = this._refresh();
+        this._refreshPromise = refresh;
+        return refresh.finally(() => {
+            if (this._refreshPromise === refresh) {
+                this._refreshPromise = undefined;
+            }
+        });
+    }
+    async _refresh() {
+        this._lastScanAt = Date.now();
+        const worktrees = await this._getMeasuredWorktrees(DEFAULT_MINIMUM_SESSION_AGE_DAYS);
+        if (this._store.isDisposed || !this._isEnabled()) {
+            return;
+        }
+        const candidates = this._getCleanupCandidates(worktrees);
+        const totalBytes = candidates.reduce((total, candidate) => total + candidate.sizeBytes, 0);
+        const totalWorktrees = candidates.reduce((total, candidate) => total + candidate.worktreeCount, 0);
+        const thresholdReached = totalWorktrees >= CLEANUP_THRESHOLD_WORKTREES || totalBytes >= CLEANUP_THRESHOLD_BYTES;
+        if (thresholdReached && !this._dismissed) {
+            this._suggestion.set(this._createSuggestion(totalWorktrees, totalBytes), undefined);
+        } else {
+            this._suggestion.set(undefined, undefined);
+        }
+    }
+    async _measureWorktrees(onProgress) {
+        const worktreeSessions = this.sessionsManagementService.getSessions().filter(
+            session => session.workspace.get()?.folders.some(folder => folder.gitRepository?.workTreeUri) === true
+        );
+        const totalWorktrees = worktreeSessions.reduce((total, session) => total + this._countWorktrees(session), 0);
+        let scannedWorktrees = 0;
+        onProgress({
+            scannedWorktrees,
+            totalWorktrees
+        });
+        const getDiskUsage = this.sessionsManagementService.getSessionWorktreeDiskUsage;
+        if (worktreeSessions.length === 0) {
+            return [];
+        }
+        if (!getDiskUsage) {
+            onProgress({
+                scannedWorktrees: totalWorktrees,
+                totalWorktrees
+            });
+            return worktreeSessions.map(session => ({
+                session,
+                sizeBytes: undefined,
+                worktreeCount: this._countWorktrees(session)
+            }));
+        }
+        const limiter = ( new Limiter(2));
+        return Promise.all(worktreeSessions.map(session => limiter.queue(async () => {
+            const worktreeCount = this._countWorktrees(session);
+            let sizeBytes;
+            try {
+                sizeBytes = await raceTimeout(
+                    getDiskUsage.call(this.sessionsManagementService, session),
+                    WORKTREE_MEASUREMENT_TIMEOUT_MS,
+                    () => this.logService.warn(
+                        `[SessionWorktreeCleanupService] Timed out measuring worktree for session ${session.sessionId}`
+                    )
+                );
+            } catch (error) {
+                this.logService.warn(
+                    `[SessionWorktreeCleanupService] Failed to measure worktree for session ${session.sessionId}`,
+                    error
+                );
+            }
+            scannedWorktrees += worktreeCount;
+            onProgress({
+                scannedWorktrees,
+                totalWorktrees
+            });
+            return {
+                session,
+                sizeBytes,
+                worktreeCount
+            };
+        })));
+    }
+    _countWorktrees(session) {
+        const worktreeUris = ( new Set());
+        for (const folder of session.workspace.get()?.folders ?? []) {
+            const worktreeUri = folder.gitRepository?.workTreeUri;
+            if (worktreeUri) {
+                worktreeUris.add(( worktreeUri.toString()));
+            }
+        }
+        return worktreeUris.size;
+    }
+    async _getMeasuredWorktrees(minimumAgeDays, token = CancellationToken.None, onProgress) {
+        const measuredSessionSignature = this._getWorktreeSessionSignature();
+        if (this._lastMeasuredWorktrees && this._lastMeasuredSessionSignature === measuredSessionSignature && Date.now() - this._lastMeasurementAt < SCAN_CACHE_DURATION_MS) {
+            return this._withCleanupState(this._lastMeasuredWorktrees, minimumAgeDays);
+        }
+        let measurement = this._measurement;
+        if (!measurement || measurement.sessionSignature !== measuredSessionSignature) {
+            let latestProgress;
+            const progressListeners = ( new Set());
+            measurement = {
+                sessionSignature: measuredSessionSignature,
+                promise: this._measureWorktrees(progress => {
+                    latestProgress = progress;
+                    for (const listener of progressListeners) {
+                        listener(progress);
+                    }
+                }),
+                progressListeners,
+                getProgress: () => latestProgress
+            };
+            this._measurement = measurement;
+            measurement.promise.then(() => {
+                if (this._measurement === measurement) {
+                    this._measurement = undefined;
+                }
+            }, () => {
+                if (this._measurement === measurement) {
+                    this._measurement = undefined;
+                }
+            });
+        }
+        if (onProgress) {
+            measurement.progressListeners.add(onProgress);
+            const progress = measurement.getProgress();
+            if (progress) {
+                onProgress(progress);
+            }
+        }
+        let worktrees;
+        try {
+            worktrees = await raceCancellationError(measurement.promise, token);
+        } finally {
+            if (onProgress) {
+                measurement.progressListeners.delete(onProgress);
+            }
+        }
+        if (this._getWorktreeSessionSignature() !== measuredSessionSignature) {
+            return this._getMeasuredWorktrees(minimumAgeDays, token, onProgress);
+        }
+        this._lastMeasuredWorktrees = worktrees;
+        this._lastMeasuredSessionSignature = measuredSessionSignature;
+        this._lastMeasurementAt = Date.now();
+        return this._withCleanupState(worktrees, minimumAgeDays);
+    }
+    _withCleanupState(worktrees, minimumAgeDays) {
+        const activeSessionId = this.sessionsService.activeSession.get()?.sessionId;
+        const cutoff = Date.now() - minimumAgeDays * DAY_MS;
+        return worktrees.map(worktree => ({
+            ...worktree,
+            cleanupState: this._getCleanupState(worktree.session, worktree.sizeBytes, activeSessionId, cutoff)
+        }));
+    }
+    _getWorktreeSessionSignature() {
+        return this.sessionsManagementService.getSessions().flatMap(
+            session => session.workspace.get()?.folders.map(folder => folder.gitRepository?.workTreeUri).filter(worktreeUri => worktreeUri !== undefined).map(worktreeUri => `${session.sessionId}\0${( worktreeUri.toString())}`) ?? []
+        ).sort().join("\n");
+    }
+    _getCleanupState(session, sizeBytes, activeSessionId, cutoff) {
+        if (sizeBytes === undefined) {
+            return "unavailable";
+        }
+        if (session.isArchived.get()) {
+            return "archived";
+        }
+        if (session.sessionId === activeSessionId) {
+            return "active";
+        }
+        if (session.status.get() === SessionStatus.InProgress) {
+            return "running";
+        }
+        if (session.status.get() === SessionStatus.NeedsInput) {
+            return "needsInput";
+        }
+        if (this.sessionsListModelService.isSessionPinned(session)) {
+            return "pinned";
+        }
+        if (session.updatedAt.get().getTime() > cutoff) {
+            return "recent";
+        }
+        if (session.status.get() === SessionStatus.Untitled) {
+            return "untitled";
+        }
+        if (session.status.get() === SessionStatus.Error) {
+            return "error";
+        }
+        return "eligible";
+    }
+    _getCleanupCandidates(worktrees) {
+        return worktrees.filter(
+            worktree => worktree.cleanupState === "eligible" && worktree.sizeBytes !== undefined
+        ).map(worktree => ({
+            session: worktree.session,
+            sizeBytes: worktree.sizeBytes,
+            worktreeCount: worktree.worktreeCount
+        })).sort(
+            (a, b) => a.session.updatedAt.get().getTime() - b.session.updatedAt.get().getTime()
+        );
+    }
+    _createSuggestion(worktreeCount, reclaimableBytes) {
+        const description = worktreeCount === 1 ? ( localize(
+            5735,
+            "1 agent session worktree has been inactive for at least 15 days and can be cleaned up, reclaiming about {0}.",
+            ByteSize.formatSize(reclaimableBytes)
+        )) : ( localize(
+            5736,
+            "{0} agent session worktrees have been inactive for at least 15 days and can be cleaned up, reclaiming about {1}.",
+            worktreeCount,
+            ByteSize.formatSize(reclaimableBytes)
+        ));
+        return {
+            description,
+            manage: async () => {
+                this.suppressForWindow();
+                await this.commandService.executeCommand(MANAGE_AGENT_SESSION_WORKTREES_COMMAND_ID);
+            },
+            disable: async () => {
+                this.suppressForWindow();
+                await this.configurationService.updateValue(
+                    AGENT_SESSIONS_STORAGE_CLEANUP_SUGGESTION_SETTING,
+                    false,
+                    ConfigurationTarget.APPLICATION
+                );
+            },
+            dismiss: () => this.suppressForWindow()
+        };
+    }
+    suppressForWindow() {
+        this._dismissed = true;
+        this._suggestion.set(undefined, undefined);
+    }
+    async getWorktrees(minimumAgeDays) {
+        const measuredSessionSignature = this._getWorktreeSessionSignature();
+        if (this._lastMeasuredWorktrees && this._lastMeasuredSessionSignature === measuredSessionSignature && Date.now() - this._lastMeasurementAt < SCAN_CACHE_DURATION_MS) {
+            return this._getWorktrees(minimumAgeDays);
+        }
+        const cancellation = ( new CancellationTokenSource());
+        try {
+            return await this.progressService.withProgress({
+                location: ProgressLocation.Notification,
+                title: ( localize(5737, "Measuring agent session worktrees...")),
+                delay: 300,
+                cancellable: true
+            }, progress => this._getWorktrees(minimumAgeDays, cancellation.token, measurementProgress => {
+                progress.report({
+                    message: ( localize(
+                        5738,
+                        "Scanned {0} of {1} worktrees",
+                        measurementProgress.scannedWorktrees,
+                        measurementProgress.totalWorktrees
+                    ))
+                });
+            }), () => cancellation.cancel());
+        } finally {
+            cancellation.dispose();
+        }
+    }
+    async _getWorktrees(minimumAgeDays, token = CancellationToken.None, onProgress) {
+        return (await this._getMeasuredWorktrees(minimumAgeDays, token, onProgress)).filter(
+            worktree => worktree.sizeBytes !== undefined && worktree.cleanupState !== "archived"
+        );
+    }
+    async cleanupWorktrees(selected) {
+        if (selected.length === 0) {
+            return false;
+        }
+        const selectedBytes = selected.reduce((total, candidate) => total + candidate.sizeBytes, 0);
+        const worktreeCount = selected.reduce((total, candidate) => total + candidate.worktreeCount, 0);
+        const confirmation = await this.dialogService.confirm({
+            message: worktreeCount === 1 ? ( localize(5739, "Clean up 1 worktree?")) : ( localize(5740, "Clean up {0} worktrees?", worktreeCount)),
+            detail: ( localize(
+                5741,
+                "This reclaims about {0} and marks the selected sessions as done. You can restore a session later to recreate its worktree.",
+                ByteSize.formatSize(selectedBytes)
+            )),
+            primaryButton: ( localize(5742, "Clean Up"))
+        });
+        if (!confirmation.confirmed) {
+            return false;
+        }
+        await this.progressService.withProgress({
+            location: ProgressLocation.Notification,
+            title: worktreeCount === 1 ? ( localize(5743, "Scheduling cleanup for 1 agent session worktree...")) : ( localize(
+                5744,
+                "Scheduling cleanup for {0} agent session worktrees...",
+                worktreeCount
+            ))
+        }, async progress => {
+            let completedWorktrees = 0;
+            for (const candidate of selected) {
+                await this.sessionsManagementService.archiveSession(candidate.session);
+                completedWorktrees += candidate.worktreeCount;
+                progress.report({
+                    increment: candidate.worktreeCount / worktreeCount * 100,
+                    message: ( localize(5745, "Scheduled {0} of {1} worktrees", completedWorktrees, worktreeCount))
+                });
+            }
+        });
+        const message = worktreeCount === 1 ? ( localize(5746, "Started cleanup for 1 worktree.")) : ( localize(5747, "Started cleanup for {0} worktrees.", worktreeCount));
+        status(message);
+        this._lastScanAt = 0;
+        this._lastMeasurementAt = 0;
+        return true;
+    }
+    _isEnabled() {
+        return this.configurationService.getValue(AGENT_SESSIONS_STORAGE_CLEANUP_SUGGESTION_SETTING) === true;
+    }
+};
+SessionWorktreeCleanupService = ( __decorate([( __param(0, ISessionsManagementService)), ( __param(1, ISessionsService)), ( __param(2, ISessionsListModelService)), ( __param(3, IDialogService)), ( __param(4, ILogService)), ( __param(5, IConfigurationService)), ( __param(6, IProgressService)), ( __param(7, ICommandService))], SessionWorktreeCleanupService));
+
+export { AGENT_SESSIONS_STORAGE_CLEANUP_SUGGESTION_SETTING, CLEANUP_THRESHOLD_BYTES, CLEANUP_THRESHOLD_WORKTREES, LEGACY_AGENT_SESSIONS_WORKTREE_LIMIT_PROMPT_SETTING, MANAGE_AGENT_SESSION_WORKTREES_COMMAND_ID, SessionWorktreeCleanupService };

package/vscode/src/vs/sessions/contrib/sessionInputBanners/browser/sessionWorktreeCleanupService.service.d.ts

@@ -0,0 +1,12 @@
+import { IObservable } from "../../../../base/common/observable.js";
+import { ISessionWorktreeCleanupSuggestion, ISessionWorktree, ISessionWorktreeCleanupCandidate } from "./sessionWorktreeCleanupService.js";
+export declare const ISessionWorktreeCleanupService: import("../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<ISessionWorktreeCleanupService>;
+export interface ISessionWorktreeCleanupService {
+    readonly _serviceBrand: undefined;
+    readonly suggestion: IObservable<ISessionWorktreeCleanupSuggestion | undefined>;
+    activate(): Promise<void>;
+    refresh(): Promise<void>;
+    suppressForWindow(): void;
+    getWorktrees(minimumAgeDays: number): Promise<readonly ISessionWorktree[]>;
+    cleanupWorktrees(candidates: readonly ISessionWorktreeCleanupCandidate[]): Promise<boolean>;
+}

package/vscode/src/vs/sessions/contrib/sessionInputBanners/browser/sessionWorktreeCleanupService.service.js

@@ -0,0 +1,6 @@
+
+import { createDecorator } from '../../../../platform/instantiation/common/instantiation.js';
+
+const ISessionWorktreeCleanupService = ( createDecorator("sessionWorktreeCleanupService"));
+
+export { ISessionWorktreeCleanupService };

package/vscode/src/vs/sessions/contrib/sessions/browser/aiCustomizationShortcutsWidget.d.ts

@@ -1,18 +1,22 @@
 import { Disposable } from "../../../../base/common/lifecycle.js";
 import { IInstantiationService } from "../../../../platform/instantiation/common/instantiation.js";
 import { IStorageService } from "../../../../platform/storage/common/storage.service.js";
-import { IMcpService } from "../../../../workbench/contrib/mcp/common/mcpTypes.service.js";
 import { IAICustomizationItemsModel } from "../../../../workbench/contrib/chat/browser/aiCustomization/aiCustomizationItemsModel.service.js";
 import { ICustomizationHarnessService } from "../../../../workbench/contrib/chat/common/customizationHarnessService.service.js";
+import { IAICustomizationMcpServerCountService } from "./customizationMcpServerCount.service.js";
+import { ILanguageModelToolsService } from "../../../../workbench/contrib/chat/common/tools/languageModelToolsService.service.js";
+import { IAgentHostToolSetEnablementService } from "../../../../workbench/contrib/chat/browser/agentSessions/agentHost/agentHostToolSetEnablementService.service.js";
 export interface IAICustomizationShortcutsWidgetOptions {
     readonly onDidChangeLayout?: () => void;
 }
 export declare class AICustomizationShortcutsWidget extends Disposable {
     private readonly instantiationService;
-    private readonly mcpService;
+    private readonly mcpServerCountService;
     private readonly itemsModel;
     private readonly harnessService;
     private readonly storageService;
+    private readonly toolsService;
+    private readonly toolEnablementService;
     private _renderDisposables;
     private _wrapper;
     private _options;
@@ -32,7 +36,7 @@ export declare class AICustomizationShortcutsWidget extends Disposable {
     readonly onDidToggleCollapsed: import("../../../../base/common/event.js").Event<boolean>;
     get collapsed(): boolean;
     get collapsedHeight(): number;
-    constructor(container: HTMLElement, options: IAICustomizationShortcutsWidgetOptions | undefined, instantiationService: IInstantiationService, mcpService: IMcpService, itemsModel: IAICustomizationItemsModel, harnessService: ICustomizationHarnessService, storageService: IStorageService);
+    constructor(container: HTMLElement, options: IAICustomizationShortcutsWidgetOptions | undefined, instantiationService: IInstantiationService, mcpServerCountService: IAICustomizationMcpServerCountService, itemsModel: IAICustomizationItemsModel, harnessService: ICustomizationHarnessService, storageService: IStorageService, toolsService: ILanguageModelToolsService, toolEnablementService: IAgentHostToolSetEnablementService);
     private _renderForCurrentMode;
     private _totalCount;
     private _render;
@@ -44,4 +48,5 @@ export declare class AICustomizationShortcutsWidget extends Disposable {
     private _renderHeaderTotalCount;
     layout(_height: number, _width: number): void;
     focus(): void;
+    hasFocus(): boolean;
 }

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

@@ -3,7 +3,7 @@ import { registerCss } from '../../../../../../../css.js';
 import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
 import * as sidebarActionButton from '../../../browser/media/sidebarActionButton.css';
 import * as customizationsToolbar from './media/customizationsToolbar.css';
-import { $ as $$1, append, clearNode, addDisposableListener, EventType, getActiveElement } from '../../../../base/browser/dom.js';
+import { $ as $$1, append, clearNode, addDisposableListener, EventType, getActiveElement, isAncestorOfActiveElement } from '../../../../base/browser/dom.js';
 import { Codicon } from '../../../../base/common/codicons.js';
 import { Emitter } from '../../../../base/common/event.js';
 import { Disposable, DisposableStore } from '../../../../base/common/lifecycle.js';
@@ -16,11 +16,13 @@ import { IInstantiationService } from '../../../../platform/instantiation/common
 import { StorageScope, StorageTarget } from '../../../../platform/storage/common/storage.js';
 import { IStorageService } from '../../../../platform/storage/common/storage.service.js';
 import { DomScrollableElement } from '../../../../base/browser/ui/scrollbar/scrollableElement.js';
-import { IMcpService } from '../../../../workbench/contrib/mcp/common/mcpTypes.service.js';
 import { IAICustomizationItemsModel } from '../../../../workbench/contrib/chat/browser/aiCustomization/aiCustomizationItemsModel.service.js';
 import { ICustomizationHarnessService } from '../../../../workbench/contrib/chat/common/customizationHarnessService.service.js';
-import { CUSTOMIZATION_ITEMS } from './customizationsToolbar.contribution.js';
+import { readTotalCustomizationCount } from './customizationsToolbar.contribution.js';
 import { Menus } from '../../../browser/menus.js';
+import { IAICustomizationMcpServerCountService } from './customizationMcpServerCount.service.js';
+import { ILanguageModelToolsService } from '../../../../workbench/contrib/chat/common/tools/languageModelToolsService.service.js';
+import { IAgentHostToolSetEnablementService } from '../../../../workbench/contrib/chat/browser/agentSessions/agentHost/agentHostToolSetEnablementService.service.js';
 import { derived } from '../../../../base/common/observableInternal/observables/derived.js';
 import { autorun } from '../../../../base/common/observableInternal/reactions/autorun.js';
 
@@ -41,17 +43,21 @@ let AICustomizationShortcutsWidget = class AICustomizationShortcutsWidget extend
         container,
         options,
         instantiationService,
-        mcpService,
+        mcpServerCountService,
         itemsModel,
         harnessService,
-        storageService
+        storageService,
+        toolsService,
+        toolEnablementService
     ) {
         super();
         this.instantiationService = instantiationService;
-        this.mcpService = mcpService;
+        this.mcpServerCountService = mcpServerCountService;
         this.itemsModel = itemsModel;
         this.harnessService = harnessService;
         this.storageService = storageService;
+        this.toolsService = toolsService;
+        this.toolEnablementService = toolEnablementService;
         this._renderDisposables = this._register(( new DisposableStore()));
         this._rootVerticalPadding = 0;
         this._headerTotalCount = 0;
@@ -84,25 +90,14 @@ let AICustomizationShortcutsWidget = class AICustomizationShortcutsWidget extend
         this._setCollapsed(this._collapsed);
     }
     _totalCount() {
-        return derived(reader => {
-            this.harnessService.activeHarness.read(reader);
-            this.harnessService.availableHarnesses.read(reader);
-            const hidden = ( new Set(this.harnessService.getActiveDescriptor().hiddenSections ?? []));
-            let total = 0;
-            for (const config of CUSTOMIZATION_ITEMS) {
-                if (config.section && ( hidden.has(config.section))) {
-                    continue;
-                }
-                if (config.modelSection) {
-                    total += this.itemsModel.getCount(config.modelSection).read(reader);
-                } else if (config.isMcp) {
-                    total += this.mcpService.servers.read(reader).length;
-                } else if (config.isPlugins) {
-                    total += this.itemsModel.getPluginCount().read(reader);
-                }
-            }
-            return total;
-        });
+        return derived(reader => readTotalCustomizationCount(
+            reader,
+            this.itemsModel,
+            this.mcpServerCountService,
+            this.toolsService,
+            this.toolEnablementService,
+            this.harnessService
+        ));
     }
     _render(parent, options) {
         const container = append(parent, $(".ai-customization-toolbar"));
@@ -117,7 +112,7 @@ let AICustomizationShortcutsWidget = class AICustomizationShortcutsWidget extend
         header.setAttribute("aria-expanded", "true");
         header.tabIndex = 0;
         const headerLabel = append(header, $("span.ai-customization-header-label"));
-        headerLabel.textContent = ( localize(4615, "Customizations"));
+        headerLabel.textContent = ( localize(5748, "Customizations"));
         this._headerTotalCountElement = append(header, $("span.ai-customization-header-total-count.hidden"));
         this._chevronElement = append(header, $("span.ai-customization-chevron"));
         this._chevronElement.setAttribute("aria-hidden", "true");
@@ -231,7 +226,10 @@ let AICustomizationShortcutsWidget = class AICustomizationShortcutsWidget extend
         }
         this._toolbar?.focus();
     }
+    hasFocus() {
+        return !!this._wrapper && isAncestorOfActiveElement(this._wrapper);
+    }
 };
-AICustomizationShortcutsWidget = ( __decorate([( __param(2, IInstantiationService)), ( __param(3, IMcpService)), ( __param(4, IAICustomizationItemsModel)), ( __param(5, ICustomizationHarnessService)), ( __param(6, IStorageService))], AICustomizationShortcutsWidget));
+AICustomizationShortcutsWidget = ( __decorate([( __param(2, IInstantiationService)), ( __param(3, IAICustomizationMcpServerCountService)), ( __param(4, IAICustomizationItemsModel)), ( __param(5, ICustomizationHarnessService)), ( __param(6, IStorageService)), ( __param(7, ILanguageModelToolsService)), ( __param(8, IAgentHostToolSetEnablementService))], AICustomizationShortcutsWidget));
 
 export { AICustomizationShortcutsWidget };

package/vscode/src/vs/sessions/contrib/sessions/browser/customizationMcpServerCount.service.d.ts

@@ -0,0 +1,6 @@
+import { IObservable } from "../../../../base/common/observable.js";
+export declare const IAICustomizationMcpServerCountService: import("../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<IAICustomizationMcpServerCountService>;
+export interface IAICustomizationMcpServerCountService {
+    readonly _serviceBrand: undefined;
+    readonly count: IObservable<number>;
+}

package/vscode/src/vs/sessions/contrib/sessions/browser/customizationMcpServerCount.service.js

@@ -0,0 +1,6 @@
+
+import { createDecorator } from '../../../../platform/instantiation/common/instantiation.js';
+
+const IAICustomizationMcpServerCountService = ( createDecorator("aiCustomizationMcpServerCountService"));
+
+export { IAICustomizationMcpServerCountService };

package/vscode/src/vs/sessions/contrib/sessions/browser/customizationsConstants.d.ts

@@ -0,0 +1 @@
+export declare const OPEN_AI_CUSTOMIZATIONS_COMMAND_ID = "sessions.customization.overview";

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

@@ -0,0 +1,5 @@
+
+
+const OPEN_AI_CUSTOMIZATIONS_COMMAND_ID = 'sessions.customization.overview';
+
+export { OPEN_AI_CUSTOMIZATIONS_COMMAND_ID };

package/vscode/src/vs/sessions/contrib/sessions/browser/customizationsNavigationState.d.ts

@@ -0,0 +1,19 @@
+import { Disposable } from "../../../../base/common/lifecycle.js";
+import { IObservable } from "../../../../base/common/observable.js";
+import { IConfigurationService } from "../../../../platform/configuration/common/configuration.service.js";
+import { ILogService } from "../../../../platform/log/common/log.service.js";
+import { IAICustomizationItemsModel } from "../../../../workbench/contrib/chat/browser/aiCustomization/aiCustomizationItemsModel.service.js";
+import { IAgentHostToolSetEnablementService } from "../../../../workbench/contrib/chat/browser/agentSessions/agentHost/agentHostToolSetEnablementService.service.js";
+import { ICustomizationHarnessService } from "../../../../workbench/contrib/chat/common/customizationHarnessService.service.js";
+import { ICustomizationMigrationService } from "../../../../workbench/contrib/chat/common/promptSyntax/service/customizationMigrationService.service.js";
+import { ILanguageModelToolsService } from "../../../../workbench/contrib/chat/common/tools/languageModelToolsService.service.js";
+import { ISessionsService } from "../../../services/sessions/browser/sessionsService.service.js";
+import { IAICustomizationMcpServerCountService } from "./customizationMcpServerCount.service.js";
+export declare class CustomizationsNavigationState extends Disposable {
+    private readonly logService;
+    readonly totalCount: IObservable<number>;
+    private readonly migrationAvailableValue;
+    readonly migrationAvailable: IObservable<boolean>;
+    constructor(enabled: IObservable<boolean>, sessionsService: ISessionsService, itemsModel: IAICustomizationItemsModel, mcpServerCountService: IAICustomizationMcpServerCountService, toolsService: ILanguageModelToolsService, toolEnablementService: IAgentHostToolSetEnablementService, harnessService: ICustomizationHarnessService, migrationService: ICustomizationMigrationService, configurationService: IConfigurationService, logService: ILogService);
+    private refreshMigrationAvailability;
+}