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

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

@@ -0,0 +1,526 @@
+
+import { registerCss } from '@codingame/monaco-vscode-api/css';
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import * as sessionsTitleBarWidget from './media/sessionsTitleBarWidget.css';
+import { reset, $, addDisposableGenericMouseDownListener, addDisposableListener, EventType, isAncestor, getDomNodePagePosition, getWindow } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { combinedDisposable, DisposableStore, MutableDisposable, toDisposable, Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { KeyCode } from '@codingame/monaco-vscode-api/vscode/vs/base/common/keyCodes';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { BaseActionViewItem } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/actionbar/actionViewItems';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { MenuRegistry, SubmenuItemAction } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions';
+import { ContextKeyExpr } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey';
+import { IContextKeyService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service';
+import { KeybindingsRegistry, KeybindingWeight } from '@codingame/monaco-vscode-api/vscode/vs/platform/keybinding/common/keybindingsRegistry';
+import { CommandsRegistry } from '@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands';
+import { ICommandService } from '@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands.service';
+import { Menus } from '@codingame/monaco-vscode-api/vscode/vs/sessions/browser/menus';
+import { IActionViewItemService } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/browser/actionViewItemService.service';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { onUnexpectedError } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
+import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
+import { AnchorPosition, AnchorAlignment } from '@codingame/monaco-vscode-api/vscode/vs/base/common/layout';
+import { ThemeIcon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/themables';
+import { IContextViewService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextview/browser/contextView.service';
+import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
+import { IQuickInputService } from '@codingame/monaco-vscode-api/vscode/vs/platform/quickinput/common/quickInput.service';
+import { IsAuxiliaryWindowContext } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/contextkeys';
+import { IWorkbenchLayoutService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/layout/browser/layoutService.service';
+import { SessionsBlockedSessionsVisibleContext, SessionsWelcomeVisibleContext } from '@codingame/monaco-vscode-api/vscode/vs/sessions/common/contextkeys';
+import { ISessionsProvidersService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsProvidersService.service';
+import { SHOW_SESSIONS_PICKER_COMMAND_ID } from './sessionsActions.js';
+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 { BlockedSessionsList, registerBlockedSessionsItemActions } from './blockedSessionsList.js';
+import { SessionActionFeedback } from './sessionActionFeedback.js';
+import { BlockedSessionsIndicatorModel } from './blockedSessionsIndicatorModel.js';
+import { getSessionWorkspaceDisplayInfo } from '../../../browser/sessionWorkspace.js';
+import { IHoverService } from '@codingame/monaco-vscode-api/vscode/vs/platform/hover/browser/hover.service';
+import { IBrowserWorkbenchEnvironmentService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/environment/browser/environmentService.service';
+import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
+
+registerCss(sessionsTitleBarWidget, 1);
+const SHOW_ALL_SESSIONS_FROM_BLOCKED_LIST_COMMAND_ID = "sessions.blockedSessions.showAllSessions";
+const IGNORE_ALL_INPUT_NEEDED_COMMAND_ID = "sessions.blockedSessions.ignoreAllInputNeeded";
+const HIDE_BLOCKED_SESSIONS_COMMAND_ID = "sessions.blockedSessions.hide";
+function registerBlockedSessionsHeaderActions() {
+    return combinedDisposable(MenuRegistry.appendMenuItem(Menus.BlockedSessionsHeader, {
+        command: {
+            id: SHOW_ALL_SESSIONS_FROM_BLOCKED_LIST_COMMAND_ID,
+            title: ( localize(4593, "Show All Sessions")),
+            icon: Codicon.listSelection
+        },
+        group: "navigation",
+        order: 1
+    }), MenuRegistry.appendMenuItem(Menus.BlockedSessionsHeader, {
+        command: {
+            id: IGNORE_ALL_INPUT_NEEDED_COMMAND_ID,
+            title: ( localize(4594, "Ignore All Input Needed")),
+            icon: Codicon.bellSlash
+        },
+        group: "navigation",
+        order: 2
+    }), MenuRegistry.appendMenuItem(Menus.BlockedSessionsHeader, {
+        command: {
+            id: HIDE_BLOCKED_SESSIONS_COMMAND_ID,
+            title: ( localize(4595, "Close")),
+            icon: Codicon.close
+        },
+        group: "z_close",
+        order: 1
+    }));
+}
+function registerBlockedSessionsHeaderCommands() {
+    return combinedDisposable(
+        CommandsRegistry.registerCommand(SHOW_ALL_SESSIONS_FROM_BLOCKED_LIST_COMMAND_ID, (_accessor, context) => {
+            context.showAllSessions();
+        }),
+        CommandsRegistry.registerCommand(IGNORE_ALL_INPUT_NEEDED_COMMAND_ID, (_accessor, context) => {
+            context.ignoreAllSessions();
+        })
+    );
+}
+let openBlockedSessionsView;
+const BLOCKED_DROPDOWN_MIN_WIDTH = 550;
+const BLOCKED_DROPDOWN_MAX_WIDTH_RATIO = 0.9;
+let SessionsTitleBarWidget = class SessionsTitleBarWidget extends BaseActionViewItem {
+    constructor(
+        action,
+        options,
+        _sessionActionFeedback,
+        _blockedIndicator,
+        sessionsManagementService,
+        sessionsService,
+        sessionsProvidersService,
+        commandService,
+        contextViewService,
+        layoutService,
+        instantiationService,
+        contextKeyService,
+        quickInputService,
+        hoverService,
+        environmentService
+    ) {
+        super(undefined, action, options);
+        this._sessionActionFeedback = _sessionActionFeedback;
+        this._blockedIndicator = _blockedIndicator;
+        this.sessionsManagementService = sessionsManagementService;
+        this.sessionsService = sessionsService;
+        this.sessionsProvidersService = sessionsProvidersService;
+        this.commandService = commandService;
+        this.contextViewService = contextViewService;
+        this.layoutService = layoutService;
+        this.instantiationService = instantiationService;
+        this.quickInputService = quickInputService;
+        this.hoverService = hoverService;
+        this._dynamicDisposables = this._register(( new DisposableStore()));
+        this._blinkListener = this._register(( new MutableDisposable()));
+        this._isRendering = false;
+        this._isQuickChat = false;
+        this._sessionTitle = environmentService.sessionTitle?.replace(/\s+/g, " ").trim() || undefined;
+        this._blockedSessionsVisibleContext = SessionsBlockedSessionsVisibleContext.bindTo(contextKeyService);
+        this._register(this._blockedIndicator.onDidRequestBlink(() => {
+            this._lastRenderState = undefined;
+            this._render();
+        }));
+        this._register(autorun(reader => {
+            const sessionData = this.sessionsService.activeSession.read(reader);
+            this._workspaceInfo = getSessionWorkspaceDisplayInfo(sessionData, reader);
+            this._isQuickChat = sessionData?.isQuickChat?.read(reader) ?? false;
+            this._lastRenderState = undefined;
+            this._render();
+        }));
+        this._register(autorun(reader => {
+            const blocked = this._blockedIndicator.blockedSessions.read(reader);
+            this._sessionActionFeedback.approvedCount.read(reader);
+            this._blockedIndicator.requiresInputKind.read(reader);
+            if (this._openContextView && this._blockedList) {
+                this._blockedList.setSessions(blocked.map(entry => entry.session));
+                this.contextViewService.layout();
+            }
+            this._render();
+        }));
+        this._register(this.sessionsManagementService.onDidChangeSessions(() => {
+            this._lastRenderState = undefined;
+            this._render();
+        }));
+        this._register(this.sessionsProvidersService.onDidChangeProviders(() => {
+            this._lastRenderState = undefined;
+            this._render();
+        }));
+        this._register(toDisposable(() => this._openContextView?.close()));
+    }
+    render(container) {
+        super.render(container);
+        this._container = container;
+        container.classList.add("agent-sessions-titlebar-container");
+        this._render();
+    }
+    setFocusable(_focusable) {}
+    onClick() {}
+    _render() {
+        if (!this._container) {
+            return;
+        }
+        if (this._isRendering) {
+            return;
+        }
+        this._isRendering = true;
+        try {
+            const approvedCount = this._sessionActionFeedback.approvedCount.get();
+            const blockedCount = this._blockedIndicator.blockedSessions.get().length;
+            const requiresInput = blockedCount > 0;
+            const showApproved = approvedCount > 0;
+            const showRequiresInput = requiresInput && !showApproved;
+            const shouldBlink = showRequiresInput && this._blockedIndicator.consumePendingBlink();
+            const requiresInputKind = this._blockedIndicator.requiresInputKind.get();
+            let renderState;
+            if (showApproved) {
+                renderState = `approved|${approvedCount}`;
+            } else if (showRequiresInput) {
+                renderState = `blocked|${blockedCount}|${requiresInputKind ?? "mixed"}`;
+            } else {
+                renderState = `normal|${this._workspaceInfo?.icon.id ?? ""}|${this._workspaceInfo?.label ?? ""}|${this._isQuickChat}`;
+            }
+            if (this._lastRenderState === renderState) {
+                return;
+            }
+            this._lastRenderState = renderState;
+            if (!requiresInput && this._openContextView) {
+                this._openContextView.close();
+            }
+            reset(this._container);
+            this._dynamicDisposables.clear();
+            this._container.removeAttribute("aria-hidden");
+            this._container.setAttribute("role", "button");
+            this._container.tabIndex = 0;
+            if (!(showRequiresInput && !shouldBlink)) {
+                this._container.classList.remove("agent-sessions-titlebar-blink");
+            }
+            this._container.classList.toggle("agent-sessions-titlebar-requires-input", showRequiresInput);
+            this._container.classList.toggle("agent-sessions-titlebar-approved", showApproved);
+            if (showApproved) {
+                this._renderApproved(approvedCount);
+            } else if (showRequiresInput) {
+                this._renderRequiresInput(blockedCount, requiresInputKind, shouldBlink);
+            } else {
+                this._renderActiveSession();
+            }
+        } finally {
+            this._isRendering = false;
+        }
+    }
+    _renderActiveSession() {
+        const container = this._container;
+        container.setAttribute("aria-label", this._sessionTitle ? ( localize(4596, "Show Sessions: {0}", this._sessionTitle)) : ( localize(4597, "Show Sessions")));
+        const workspaceInfo = this._workspaceInfo;
+        const sessionPill = $("div.agent-sessions-titlebar-pill");
+        const centerGroup = $("div.agent-sessions-titlebar-center");
+        if (workspaceInfo) {
+            const workspaceIconEl = $(
+                `div.agent-sessions-titlebar-workspace-icon${ThemeIcon.asCSSSelector(workspaceInfo.icon)}`,
+                {
+                    "aria-hidden": "true"
+                }
+            );
+            centerGroup.appendChild(workspaceIconEl);
+            const workspaceEl = $("div.agent-sessions-titlebar-workspace");
+            workspaceEl.textContent = this._sessionTitle ?? workspaceInfo.label;
+            centerGroup.appendChild(workspaceEl);
+            this._dynamicDisposables.add(this.hoverService.setupDelayedHover(workspaceEl, {
+                content: workspaceEl.textContent
+            }));
+        } else if (this._isQuickChat) {
+            const workspaceIconEl = $(
+                `div.agent-sessions-titlebar-workspace-icon${ThemeIcon.asCSSSelector(Codicon.commentDiscussion)}`,
+                {
+                    "aria-hidden": "true"
+                }
+            );
+            centerGroup.appendChild(workspaceIconEl);
+            const workspaceEl = $("div.agent-sessions-titlebar-workspace");
+            workspaceEl.textContent = this._sessionTitle ?? ( localize(4598, "No workspace"));
+            centerGroup.appendChild(workspaceEl);
+            this._dynamicDisposables.add(this.hoverService.setupDelayedHover(workspaceEl, {
+                content: workspaceEl.textContent
+            }));
+        } else if (this._sessionTitle) {
+            const titleElement = $("div.agent-sessions-titlebar-workspace");
+            titleElement.textContent = this._sessionTitle;
+            centerGroup.appendChild(titleElement);
+            this._dynamicDisposables.add(this.hoverService.setupDelayedHover(titleElement, {
+                content: this._sessionTitle
+            }));
+        }
+        sessionPill.appendChild(centerGroup);
+        this._dynamicDisposables.add(addDisposableGenericMouseDownListener(sessionPill, e => {
+            e.preventDefault();
+            e.stopPropagation();
+        }));
+        this._dynamicDisposables.add(addDisposableListener(sessionPill, EventType.CLICK, e => {
+            e.preventDefault();
+            e.stopPropagation();
+            this._showSessionsPicker();
+        }));
+        container.appendChild(sessionPill);
+        this._dynamicDisposables.add(addDisposableListener(container, EventType.KEY_DOWN, e => {
+            if (e.key === "Enter" || e.key === " ") {
+                e.preventDefault();
+                e.stopPropagation();
+                this._showSessionsPicker();
+            }
+        }));
+    }
+    _renderRequiresInput(count, kind, shouldBlink) {
+        const container = this._container;
+        const label = this._blockedIndicator.getRequiresInputLabel(count, kind);
+        container.setAttribute("aria-label", label);
+        const pill = $("div.agent-sessions-titlebar-pill");
+        const labelEl = $("div.agent-sessions-titlebar-requires-input-label");
+        labelEl.textContent = label;
+        pill.appendChild(labelEl);
+        this._dynamicDisposables.add(addDisposableGenericMouseDownListener(pill, e => {
+            e.preventDefault();
+            e.stopPropagation();
+        }));
+        this._dynamicDisposables.add(addDisposableListener(pill, EventType.CLICK, e => {
+            e.preventDefault();
+            e.stopPropagation();
+            this._toggleBlockedSessions();
+        }));
+        container.appendChild(pill);
+        this._dynamicDisposables.add(addDisposableListener(container, EventType.KEY_DOWN, e => {
+            if (e.key === "Enter" || e.key === " ") {
+                e.preventDefault();
+                e.stopPropagation();
+                this._toggleBlockedSessions();
+            }
+        }));
+        if (shouldBlink) {
+            this._triggerAttentionBlink();
+        }
+    }
+    _renderApproved(count) {
+        const container = this._container;
+        const label = count === 1 ? ( localize(4599, "Approved 1 session")) : ( localize(4600, "Approved {0} sessions", count));
+        container.setAttribute("aria-label", label);
+        const pill = $("div.agent-sessions-titlebar-pill");
+        const labelEl = $("div.agent-sessions-titlebar-approved-label");
+        labelEl.textContent = label;
+        pill.appendChild(labelEl);
+        this._dynamicDisposables.add(addDisposableGenericMouseDownListener(pill, e => {
+            e.preventDefault();
+            e.stopPropagation();
+        }));
+        this._dynamicDisposables.add(addDisposableListener(pill, EventType.CLICK, e => {
+            e.preventDefault();
+            e.stopPropagation();
+            this._activateDefaultAction();
+        }));
+        container.appendChild(pill);
+        this._dynamicDisposables.add(addDisposableListener(container, EventType.KEY_DOWN, e => {
+            if (e.key === "Enter" || e.key === " ") {
+                e.preventDefault();
+                e.stopPropagation();
+                this._activateDefaultAction();
+            }
+        }));
+    }
+    _activateDefaultAction() {
+        const requiresInput = this._blockedIndicator.blockedSessions.get().length > 0;
+        if (requiresInput) {
+            this._toggleBlockedSessions();
+        } else {
+            this._showSessionsPicker();
+        }
+    }
+    _triggerAttentionBlink() {
+        const container = this._container;
+        if (!container) {
+            return;
+        }
+        container.classList.remove("agent-sessions-titlebar-blink");
+        container.getBoundingClientRect();
+        container.classList.add("agent-sessions-titlebar-blink");
+        this._blinkListener.value = addDisposableListener(container, "animationend", () => {
+            container.classList.remove("agent-sessions-titlebar-blink");
+            this._blinkListener.clear();
+        });
+    }
+    _toggleBlockedSessions() {
+        if (this._openContextView) {
+            this._openContextView.close();
+            return;
+        }
+        this._showBlockedSessions();
+    }
+    _showBlockedSessions() {
+        const container = this._container;
+        if (!container) {
+            return;
+        }
+        if (this._blockedIndicator.blockedSessions.get().length === 0) {
+            return;
+        }
+        const width = this._computeBlockedDropdownWidth(container);
+        const store = ( new DisposableStore());
+        this._openContextView = this.contextViewService.showContextView({
+            getAnchor: () => this._getBlockedDropdownAnchor(container),
+            anchorAlignment: AnchorAlignment.LEFT,
+            anchorPosition: AnchorPosition.BELOW,
+            render: viewContainer => {
+                const list = store.add(
+                    this.instantiationService.createInstance(BlockedSessionsList, viewContainer, {
+                        width,
+                        approvalModel: this._blockedIndicator.approvalModel,
+                        ciFixModel: this._blockedIndicator.ciFixModel,
+                        onSessionOpen: (resource, preserveFocus, sideBySide) => {
+                            this._openContextView?.close();
+                            this._openBlockedSession(resource, preserveFocus, sideBySide);
+                        },
+                        onIgnoreSession: session => this._blockedIndicator.ignoreSession(session),
+                        onShowAllSessions: () => {
+                            this._openContextView?.close();
+                            this._showSessionsPicker();
+                        },
+                        onIgnoreAllSessions: () => this._blockedIndicator.ignoreAllSessions(),
+                        onClose: () => this._openContextView?.close()
+                    })
+                );
+                list.setSessions(this._blockedIndicator.blockedSessions.get().map(entry => entry.session));
+                store.add(list.onDidChangeContentHeight(() => this.contextViewService.layout()));
+                store.add(list.onDidApproveSession(approved => {
+                    this._blockedIndicator.dismissApproval(approved);
+                    this._sessionActionFeedback.notifyApproved();
+                }));
+                store.add(this.layoutService.onDidLayoutActiveContainer(() => {
+                    list.setWidth(this._computeBlockedDropdownWidth(container));
+                    this.contextViewService.layout();
+                }));
+                store.add(this.quickInputService.onShow(() => this._openContextView?.close()));
+                this._blockedList = list;
+                return store;
+            },
+            focus: () => this._blockedList?.focus(),
+            onDOMEvent: e => {
+                if (e.type === EventType.CLICK) {
+                    const target = e.target;
+                    if (target && !isAncestor(target, this.contextViewService.getContextViewElement()) && !isAncestor(target, container)) {
+                        this._openContextView?.close();
+                    }
+                }
+            },
+            onHide: () => {
+                this._blockedSessionsVisibleContext.set(false);
+                store.dispose();
+                this._openContextView = undefined;
+                openBlockedSessionsView = undefined;
+                this._blockedList = undefined;
+            }
+        });
+        openBlockedSessionsView = this._openContextView;
+        this._blockedSessionsVisibleContext.set(true);
+    }
+    _computeBlockedDropdownWidth(container) {
+        const anchorWidth = getDomNodePagePosition(container).width;
+        const windowWidth = getWindow(container).innerWidth;
+        const minWidth = Math.max(anchorWidth, BLOCKED_DROPDOWN_MIN_WIDTH);
+        const maxWidth = windowWidth * BLOCKED_DROPDOWN_MAX_WIDTH_RATIO;
+        return Math.round(Math.min(minWidth, maxWidth));
+    }
+    _getBlockedDropdownAnchor(container) {
+        const position = getDomNodePagePosition(container);
+        const width = this._computeBlockedDropdownWidth(container);
+        const centerX = position.left + position.width / 2;
+        return {
+            x: Math.round(centerX - width / 2),
+            y: position.top,
+            width: 0,
+            height: position.height
+        };
+    }
+    _openBlockedSession(resource, preserveFocus, sideBySide) {
+        if (sideBySide) {
+            const session = this.sessionsManagementService.getSession(resource);
+            if (session) {
+                this.sessionsService.openSessionToSide(session, {
+                    preserveFocus,
+                    source: "sessionsList"
+                }).catch(onUnexpectedError);
+                return;
+            }
+        }
+        this.sessionsService.openSession(resource, {
+            preserveFocus,
+            source: "sessionsList"
+        }).catch(onUnexpectedError);
+    }
+    _showSessionsPicker() {
+        this.commandService.executeCommand(SHOW_SESSIONS_PICKER_COMMAND_ID);
+    }
+};
+SessionsTitleBarWidget = ( __decorate([( __param(4, ISessionsManagementService)), ( __param(5, ISessionsService)), ( __param(6, ISessionsProvidersService)), ( __param(7, ICommandService)), ( __param(8, IContextViewService)), ( __param(9, IWorkbenchLayoutService)), ( __param(10, IInstantiationService)), ( __param(11, IContextKeyService)), ( __param(12, IQuickInputService)), ( __param(13, IHoverService)), ( __param(14, IBrowserWorkbenchEnvironmentService))], SessionsTitleBarWidget));
+let SessionsTitleBarContribution = class SessionsTitleBarContribution extends Disposable {
+    static {
+        this.ID = "workbench.contrib.agentSessionsTitleBar";
+    }
+    constructor(actionViewItemService, instantiationService, logService) {
+        super();
+        const sessionActionFeedback = this._register(( new SessionActionFeedback()));
+        const blockedIndicator = this._register(instantiationService.createInstance(
+            BlockedSessionsIndicatorModel,
+            undefined,
+            undefined,
+            undefined
+        ));
+        this._register(MenuRegistry.appendMenuItem(Menus.CommandCenter, {
+            submenu: Menus.TitleBarSessionTitle,
+            title: ( localize(4601, "Agent Sessions")),
+            order: 101,
+            when: ( ContextKeyExpr.and(( IsAuxiliaryWindowContext.negate()), ( SessionsWelcomeVisibleContext.negate())))
+        }));
+        this._register(MenuRegistry.appendMenuItem(Menus.TitleBarSessionTitle, {
+            command: {
+                id: SHOW_SESSIONS_PICKER_COMMAND_ID,
+                title: ( localize(4602, "Show Sessions"))
+            },
+            group: "a_sessions",
+            order: 1,
+            when: ( IsAuxiliaryWindowContext.negate())
+        }));
+        this._register(registerBlockedSessionsHeaderCommands());
+        this._register(registerBlockedSessionsHeaderActions());
+        this._register(registerBlockedSessionsItemActions());
+        this._register(
+            actionViewItemService.register(Menus.CommandCenter, Menus.TitleBarSessionTitle, (action, options) => {
+                if (!(action instanceof SubmenuItemAction)) {
+                    return undefined;
+                }
+                logService.trace("[SessionsTitleBar] creating the title bar widget");
+                return instantiationService.createInstance(
+                    SessionsTitleBarWidget,
+                    action,
+                    options,
+                    sessionActionFeedback,
+                    blockedIndicator
+                );
+            }, undefined)
+        );
+    }
+};
+SessionsTitleBarContribution = ( __decorate([( __param(0, IActionViewItemService)), ( __param(1, IInstantiationService)), ( __param(2, ILogService))], SessionsTitleBarContribution));
+KeybindingsRegistry.registerCommandAndKeybindingRule({
+    id: HIDE_BLOCKED_SESSIONS_COMMAND_ID,
+    weight: KeybindingWeight.SessionsContrib + 100,
+    when: SessionsBlockedSessionsVisibleContext,
+    primary: KeyCode.Escape,
+    handler: (_accessor, context) => {
+        if (context) {
+            context.close();
+        } else {
+            openBlockedSessionsView?.close();
+        }
+    }
+});
+
+export { SessionsTitleBarContribution, SessionsTitleBarWidget, registerBlockedSessionsHeaderActions, registerBlockedSessionsHeaderCommands };

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

@@ -0,0 +1,64 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+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 { IModelContentChangedEvent } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/textModelEvents";
+import { IActiveSession } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/sessionsManagement";
+/** Characters the user typed into one resource while `session` was active. */
+export interface ITypedCharactersEntry {
+    /**
+     * The session that was active while the characters were typed, captured at
+     * that moment so attribution does not depend on which session is active
+     * when the buffered batch is eventually reported.
+     */
+    readonly session: IActiveSession;
+    readonly resource: URI;
+    readonly characters: number;
+}
+/** How long typed characters are buffered before they are reported. Exported for tests. */
+export declare const TYPED_CHARACTERS_REPORT_DELAY = 5000;
+/**
+ * How often reporting an entry may be deferred before it is dropped. Bounds
+ * how long typing is retained for a session whose workspace never resolves.
+ * Exported for tests.
+ */
+export declare const MAX_TYPED_CHARACTERS_RETRIES = 3;
+/**
+ * Counts the characters the user manually types into the text models of this
+ * window and reports them per resource and originating session.
+ *
+ * Only models of the window this tracker runs in are observed, which is what
+ * scopes the counts to the Agents window: a regular window editing the same
+ * folder has its own renderer with its own models and never reaches this
+ * tracker.
+ *
+ * Typing produces one content change per keystroke, so counts are buffered and
+ * reported in batches instead of on every change. The active session is still
+ * captured per keystroke, so a batch reported after the user switched sessions
+ * stays attributed to the session it was typed into.
+ */
+export declare class SessionsTypedCharactersTracker extends Disposable {
+    private readonly _getActiveSession;
+    private readonly _report;
+    private readonly _pending;
+    private readonly _modelListeners;
+    private readonly _reportScheduler;
+    /**
+     * @param _report Consumes a batch and returns the entries it could not
+     * attribute yet, which are retried instead of being dropped.
+     */
+    constructor(_getActiveSession: () => IActiveSession | undefined, _report: (entries: readonly ITypedCharactersEntry[]) => readonly ITypedCharactersEntry[], modelService: IModelService);
+    /** Reports everything buffered so far, retaining whatever the consumer could not attribute yet. */
+    flush(): void;
+    private _trackModel;
+    private _handleContentChange;
+    private _add;
+}
+/**
+ * Sums the characters inserted by manual typing in `e`, ignoring everything
+ * the user did not type themselves (agent edits, accepted suggestions, paste,
+ * undo/redo, …).
+ *
+ * `detailedReasons[i]` describes the next `detailedReasonsChangeLengths[i]`
+ * entries of `changes`, so both lists are walked in lockstep.
+ */
+export declare function countTypedCharacters(e: IModelContentChangedEvent): number;