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

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

@@ -0,0 +1,320 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Disposable, toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
+import { IProductService } from '@codingame/monaco-vscode-api/vscode/vs/platform/product/common/productService.service';
+import { AgentSessionApprovalModel, agentSessionApprovalId, AgentSessionApprovalKind } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentSessionApprovalModel';
+import { ISessionsService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsService.service';
+import { BlockedSessions, BlockedSessionReason, describeBlockedSessions } from '../../blockedSessions/browser/blockedSessions.js';
+import { BlockedSessionsCIFixModel } from './blockedSessionsCIFixModel.js';
+import { getFirstApprovalAcrossChats } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/sessions/browser/views/sessionsList';
+import { observableValue } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableValue';
+import { derived } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/derived';
+import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
+
+const LOG_PREFIX = "[BlockedSessionsIndicator]";
+var RequiresInputKind;
+(function(RequiresInputKind) {
+    RequiresInputKind[RequiresInputKind["TerminalApproval"] = 0] = "TerminalApproval";
+    RequiresInputKind[RequiresInputKind["Question"] = 1] = "Question";
+    RequiresInputKind[RequiresInputKind["FailingCI"] = 2] = "FailingCI";
+})(RequiresInputKind || (RequiresInputKind = {}));
+let BlockedSessionsIndicatorModel = class BlockedSessionsIndicatorModel extends Disposable {
+    get approvalModel() {
+        return this._approvalModel;
+    }
+    get ciFixModel() {
+        return this._ciFixModel;
+    }
+    constructor(
+        approvalModel,
+        blockedSessions,
+        ciFixModel,
+        _sessionsService,
+        instantiationService,
+        productService,
+        _logService
+    ) {
+        super();
+        this._sessionsService = _sessionsService;
+        this._logService = _logService;
+        this._ignoredBlockOccurrences = observableValue("ignoredBlockOccurrences", ( new Map()));
+        this._lastBlockedOccurrences = ( new Map());
+        this._pendingBlinkOccurrences = ( new Map());
+        this._onDidRequestBlink = this._register(( new Emitter()));
+        this.onDidRequestBlink = this._onDidRequestBlink.event;
+        this._approvalModel = approvalModel ?? this._register(instantiationService.createInstance(AgentSessionApprovalModel));
+        this._blockedSessionsModel = blockedSessions ?? this._register(instantiationService.createInstance(BlockedSessions));
+        this._ciFixModel = ciFixModel ?? this._register(instantiationService.createInstance(BlockedSessionsCIFixModel));
+        const enabled = productService.quality !== "stable";
+        this._logService.trace(`${LOG_PREFIX} created (enabled: ${enabled})`);
+        this._register(toDisposable(() => this._logService.trace(
+            `${LOG_PREFIX} disposed, discarding ${this._ignoredBlockOccurrences.get().size} acknowledged occurrence(s)`
+        )));
+        this.blockedSessions = derived(this, reader => {
+            if (!enabled) {
+                return [];
+            }
+            const visibleSessionIds = ( new Set());
+            for (const session of this._sessionsService.visibleSessions.read(reader)) {
+                if (session) {
+                    visibleSessionIds.add(session.sessionId);
+                }
+            }
+            const ignoredOccurrences = this._ignoredBlockOccurrences.read(reader);
+            const ciFixHidden = this._ciFixModel.hiddenSessions.read(reader);
+            return this._blockedSessionsModel.blockedSessionsWithReasons.read(reader).filter(blocked => !( visibleSessionIds.has(blocked.session.sessionId)) && !( ciFixHidden.has(blocked.session.sessionId)) && !this._isBlockIgnored(blocked, ignoredOccurrences, reader));
+        });
+        this.requiresInputKind = derived(this, reader => {
+            const blocked = this.blockedSessions.read(reader);
+            if (blocked.length === 0) {
+                return undefined;
+            }
+            let common;
+            let hasCommon = false;
+            for (const entry of blocked) {
+                const kind = this._kindOf(entry, reader);
+                if (kind === undefined) {
+                    return undefined;
+                }
+                if (!hasCommon) {
+                    common = kind;
+                    hasCommon = true;
+                } else if (common !== kind) {
+                    return undefined;
+                }
+            }
+            return common;
+        });
+        this._register(autorun(reader => {
+            if (!enabled) {
+                return;
+            }
+            const blockedSessions = this._blockedSessionsModel.blockedSessionsWithReasons.read(reader);
+            const blockedById = ( new Map(blockedSessions.map(entry => [entry.session.sessionId, entry])));
+            const visibleSessionIds = ( new Set(
+                this._sessionsService.visibleSessions.read(reader).filter(session => session !== undefined).map(session => session.sessionId)
+            ));
+            const ignoredOccurrences = this._ignoredBlockOccurrences.read(reader);
+            const next = ( new Map(ignoredOccurrences));
+            let changed = false;
+            for (const [sessionId, acknowledged] of ignoredOccurrences) {
+                const blockedSession = blockedById.get(sessionId);
+                if (blockedSession) {
+                    const occurrenceId = this._getBlockOccurrenceId(blockedSession, reader, acknowledged.occurrenceId);
+                    if (occurrenceId !== acknowledged.occurrenceId) {
+                        next.delete(sessionId);
+                        changed = true;
+                        this._logService.trace(
+                            `${LOG_PREFIX} releasing acknowledgement of ${sessionId}: new occurrence ${occurrenceId} replaces ${acknowledged.occurrenceId}`
+                        );
+                    }
+                    continue;
+                }
+                if (acknowledged.reason === BlockedSessionReason.FailingCI) {
+                    this._logService.trace(
+                        `${LOG_PREFIX} keeping acknowledgement of ${sessionId} (${acknowledged.occurrenceId}) while it is not reported as blocked`
+                    );
+                    continue;
+                }
+                next.delete(sessionId);
+                changed = true;
+                this._logService.trace(
+                    `${LOG_PREFIX} releasing acknowledgement of ${sessionId} (${acknowledged.occurrenceId}): no longer blocked`
+                );
+            }
+            for (const blockedSession of ( blockedById.values())) {
+                const sessionId = blockedSession.session.sessionId;
+                if (!( visibleSessionIds.has(sessionId))) {
+                    continue;
+                }
+                const occurrenceId = this._getBlockOccurrenceId(blockedSession, reader, next.get(sessionId)?.occurrenceId);
+                if (next.get(sessionId)?.occurrenceId !== occurrenceId) {
+                    next.set(sessionId, {
+                        occurrenceId,
+                        reason: blockedSession.reason
+                    });
+                    changed = true;
+                    this._logService.trace(
+                        `${LOG_PREFIX} acknowledging ${sessionId} (${occurrenceId}): the session is visible`
+                    );
+                }
+            }
+            if (changed) {
+                this._ignoredBlockOccurrences.set(next, undefined);
+            }
+        }));
+        this._register(autorun(reader => {
+            if (!enabled) {
+                return;
+            }
+            const ignoredOccurrences = this._ignoredBlockOccurrences.read(reader);
+            const modelBlocked = this._blockedSessionsModel.blockedSessionsWithReasons.read(reader);
+            const currentOccurrences = ( new Map(
+                modelBlocked.map(blocked => [blocked.session.sessionId, this._getBlockOccurrenceId(
+                    blocked,
+                    reader,
+                    ignoredOccurrences.get(blocked.session.sessionId)?.occurrenceId
+                )])
+            ));
+            const previousOccurrences = this._lastBlockedOccurrences;
+            this._lastBlockedOccurrences = currentOccurrences;
+            const visibleSessionIds = ( new Set());
+            for (const session of this._sessionsService.visibleSessions.read(reader)) {
+                if (session) {
+                    visibleSessionIds.add(session.sessionId);
+                }
+            }
+            for (const [sessionId, occurrenceId] of this._pendingBlinkOccurrences) {
+                if (currentOccurrences.get(sessionId) !== occurrenceId || ( visibleSessionIds.has(sessionId))) {
+                    this._pendingBlinkOccurrences.delete(sessionId);
+                }
+            }
+            let queued = false;
+            for (const blocked of modelBlocked) {
+                const sessionId = blocked.session.sessionId;
+                const occurrenceId = currentOccurrences.get(sessionId);
+                if (previousOccurrences.get(sessionId) !== occurrenceId && !( visibleSessionIds.has(sessionId))) {
+                    this._pendingBlinkOccurrences.set(sessionId, occurrenceId);
+                    queued = true;
+                    this._logService.trace(`${LOG_PREFIX} queued attention blink for ${sessionId} (${occurrenceId})`);
+                }
+            }
+            if (queued) {
+                this._onDidRequestBlink.fire();
+            }
+        }));
+        this._register(autorun(reader => {
+            const surfaced = this.blockedSessions.read(reader);
+            this._logService.trace(
+                `${LOG_PREFIX} surfacing ${surfaced.length} blocked session(s): ${describeBlockedSessions(surfaced)}`
+            );
+        }));
+    }
+    consumePendingBlink() {
+        if (this._pendingBlinkOccurrences.size === 0) {
+            return false;
+        }
+        const ignoredOccurrences = this._ignoredBlockOccurrences.get();
+        const surfacedOccurrences = ( new Map(
+            this.blockedSessions.get().map(blocked => [blocked.session.sessionId, this._getBlockOccurrenceId(
+                blocked,
+                undefined,
+                ignoredOccurrences.get(blocked.session.sessionId)?.occurrenceId
+            )])
+        ));
+        let shouldBlink = false;
+        for (const [sessionId, occurrenceId] of this._pendingBlinkOccurrences) {
+            if (surfacedOccurrences.get(sessionId) === occurrenceId) {
+                shouldBlink = true;
+                break;
+            }
+        }
+        this._pendingBlinkOccurrences.clear();
+        return shouldBlink;
+    }
+    ignoreSession(session) {
+        const blocked = this._blockedSessionsModel.blockedSessionsWithReasons.get().find(entry => entry.session.sessionId === session.sessionId);
+        if (!blocked) {
+            this._logService.trace(
+                `${LOG_PREFIX} ignore requested for ${session.sessionId}, but it is not reported as blocked`
+            );
+            return;
+        }
+        this._ignoreOccurrence(blocked, this._getBlockOccurrenceId(
+            blocked,
+            undefined,
+            this._ignoredBlockOccurrences.get().get(session.sessionId)?.occurrenceId
+        ));
+    }
+    ignoreAllSessions() {
+        const blockedSessions = this.blockedSessions.get();
+        if (blockedSessions.length === 0) {
+            return;
+        }
+        const next = ( new Map(this._ignoredBlockOccurrences.get()));
+        for (const blocked of blockedSessions) {
+            const sessionId = blocked.session.sessionId;
+            const occurrenceId = this._getBlockOccurrenceId(blocked, undefined, next.get(sessionId)?.occurrenceId);
+            next.set(sessionId, {
+                occurrenceId,
+                reason: blocked.reason
+            });
+            this._logService.trace(`${LOG_PREFIX} ignoring ${sessionId} (${occurrenceId}): ignore all`);
+        }
+        this._ignoredBlockOccurrences.set(next, undefined);
+    }
+    dismissApproval(approved) {
+        const blocked = this._blockedSessionsModel.blockedSessionsWithReasons.get().find(entry => entry.session.sessionId === approved.session.sessionId);
+        if (!blocked || blocked.reason !== BlockedSessionReason.NeedsInput) {
+            return;
+        }
+        this._ignoreOccurrence(blocked, this._approvalOccurrenceId(blocked, approved.approvalId));
+    }
+    getRequiresInputLabel(count, kind) {
+        switch (kind) {
+        case RequiresInputKind.TerminalApproval:
+            return count === 1 ? ( localize(4498, "1 session requires terminal approval")) : ( localize(4499, "{0} sessions require terminal approval", count));
+        case RequiresInputKind.Question:
+            return count === 1 ? ( localize(4500, "1 session has a question")) : ( localize(4501, "{0} sessions have questions", count));
+        case RequiresInputKind.FailingCI:
+            return count === 1 ? ( localize(4502, "1 session is failing CI")) : ( localize(4503, "{0} sessions are failing CI", count));
+        default:
+            return count === 1 ? ( localize(4504, "1 session requires input")) : ( localize(4505, "{0} sessions require input", count));
+        }
+    }
+    _ignoreOccurrence(blocked, occurrenceId) {
+        const next = ( new Map(this._ignoredBlockOccurrences.get()));
+        next.set(blocked.session.sessionId, {
+            occurrenceId,
+            reason: blocked.reason
+        });
+        this._ignoredBlockOccurrences.set(next, undefined);
+        this._logService.trace(`${LOG_PREFIX} ignoring ${blocked.session.sessionId} (${occurrenceId})`);
+    }
+    _isBlockIgnored(blocked, ignoredOccurrences, reader) {
+        const acknowledged = ignoredOccurrences.get(blocked.session.sessionId);
+        return acknowledged !== undefined && this._getBlockOccurrenceId(blocked, reader, acknowledged.occurrenceId) === acknowledged.occurrenceId;
+    }
+    _getBlockOccurrenceId(blocked, reader, ignoredOccurrence) {
+        if (blocked.reason !== BlockedSessionReason.NeedsInput) {
+            return blocked.occurrenceId;
+        }
+        const approval = getFirstApprovalAcrossChats(this._approvalModel, blocked.session, reader);
+        if (approval) {
+            return this._approvalOccurrenceId(blocked, agentSessionApprovalId(approval));
+        }
+        const approvalPrefix = this._approvalOccurrenceId(blocked, "");
+        return ignoredOccurrence?.startsWith(approvalPrefix) ? ignoredOccurrence : blocked.occurrenceId;
+    }
+    _approvalOccurrenceId(blocked, approvalId) {
+        return `${blocked.occurrenceId}:approval:${approvalId}`;
+    }
+    _kindOf(blocked, reader) {
+        switch (blocked.reason) {
+        case BlockedSessionReason.FailingCI:
+            return RequiresInputKind.FailingCI;
+        case BlockedSessionReason.NeedsInput:
+            {
+                const approval = getFirstApprovalAcrossChats(this._approvalModel, blocked.session, reader);
+                switch (approval?.kind) {
+                case AgentSessionApprovalKind.Terminal:
+                    return RequiresInputKind.TerminalApproval;
+                case AgentSessionApprovalKind.Question:
+                    return RequiresInputKind.Question;
+                default:
+                    return undefined;
+                }
+            }
+        default:
+            return undefined;
+        }
+    }
+};
+BlockedSessionsIndicatorModel = ( __decorate([( __param(3, ISessionsService)), ( __param(4, IInstantiationService)), ( __param(5, IProductService)), ( __param(6, ILogService))], BlockedSessionsIndicatorModel));
+
+export { BlockedSessionsIndicatorModel, RequiresInputKind };

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

@@ -0,0 +1,65 @@
+import { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
+import { Disposable, IDisposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { ISession } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/session";
+import { IApprovedSession, ISessionCIFixModel } from "@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/sessions/browser/views/sessionsList";
+import { AgentSessionApprovalModel } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentSessionApprovalModel";
+export declare const IGNORE_INPUT_NEEDED_COMMAND_ID = "sessions.blockedSessions.ignoreInputNeeded";
+export declare const IGNORE_CI_FAILURE_COMMAND_ID = "sessions.blockedSessions.ignoreCIFailure";
+export interface IBlockedSessionsHeaderActionContext {
+    readonly showAllSessions: () => void;
+    readonly ignoreAllSessions: () => void;
+    readonly close: () => void;
+}
+/** Register the actions shown in blocked-session row toolbars. */
+export declare function registerBlockedSessionsItemActions(): IDisposable;
+export interface IBlockedSessionsListOptions {
+    /** Invoked when a session row is activated (clicked or opened via keyboard). */
+    readonly onSessionOpen: (resource: URI, preserveFocus: boolean, sideBySide: boolean) => void;
+    /** Width of the list, in pixels. Defaults to a fixed width when omitted. */
+    readonly width?: number;
+    /** Approval model forwarded to the underlying list (see {@link ISessionsFlatListOptions.approvalModel}). */
+    readonly approvalModel?: AgentSessionApprovalModel;
+    /** Fix-CI model forwarded to the underlying list (see {@link ISessionsFlatListOptions.ciFixModel}). */
+    readonly ciFixModel?: ISessionCIFixModel;
+    /** Ignores the session's current blocked occurrence. */
+    readonly onIgnoreSession: (session: ISession) => void;
+    /** Opens the full sessions picker. */
+    readonly onShowAllSessions: () => void;
+    /** Ignores every blocked occurrence currently shown. */
+    readonly onIgnoreAllSessions: () => void;
+    /** Closes the surrounding blocked-sessions overlay. */
+    readonly onClose: () => void;
+}
+/**
+ * A self-sizing, flat list of blocked sessions.
+ *
+ * Wraps {@link SessionsFlatList} with the fixed width and bounded height used by
+ * the blocked-sessions dropdown in the sessions titlebar. Hosts append it to a
+ * container, push sessions via {@link setSessions}, and listen to
+ * {@link onDidChangeContentHeight} to reposition the surrounding surface (e.g. a
+ * context view) as rows resolve their heights.
+ */
+export declare class BlockedSessionsList extends Disposable {
+    private readonly _onDidChangeContentHeight;
+    /** Fires when the list resizes and the host should re-layout its container. */
+    readonly onDidChangeContentHeight: Event<void>;
+    private readonly _onDidApproveSession;
+    /** Fires when a session's pending action is approved from its "Allow" button. */
+    readonly onDidApproveSession: Event<IApprovedSession>;
+    private readonly _rowsContainer;
+    private readonly _list;
+    private _width;
+    constructor(container: HTMLElement, options: IBlockedSessionsListOptions, instantiationService: IInstantiationService);
+    /** Replace the sessions shown in the list and resize to fit their content. */
+    setSessions(sessions: readonly ISession[]): void;
+    /** Move keyboard focus into the list. */
+    focus(): void;
+    /**
+     * Update the list width (e.g. when the anchoring widget reflows as the window
+     * resizes) and re-layout to the new width.
+     */
+    setWidth(width: number): void;
+    private _layout;
+}

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

@@ -0,0 +1,129 @@
+
+import { registerCss } from '@codingame/monaco-vscode-api/css';
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import * as blockedSessionsList from './media/blockedSessionsList.css';
+import { append, $ } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { status } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/aria/aria';
+import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
+import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { combinedDisposable, Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { MenuWorkbenchToolBar, HiddenItemStrategy } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/browser/toolbar';
+import { MenuRegistry } 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 { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { Menus } from '@codingame/monaco-vscode-api/vscode/vs/sessions/browser/menus';
+import { SessionStatus } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/session';
+import { SessionItemStatusContext, SessionsFlatList } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/sessions/browser/views/sessionsList';
+
+registerCss(blockedSessionsList, 1);
+const IGNORE_INPUT_NEEDED_COMMAND_ID = "sessions.blockedSessions.ignoreInputNeeded";
+const IGNORE_CI_FAILURE_COMMAND_ID = "sessions.blockedSessions.ignoreCIFailure";
+function registerBlockedSessionsItemActions() {
+    return combinedDisposable(MenuRegistry.appendMenuItem(Menus.BlockedSessionsItem, {
+        command: {
+            id: IGNORE_INPUT_NEEDED_COMMAND_ID,
+            title: ( localize(4506, "Ignore Input Needed")),
+            icon: Codicon.bellSlash
+        },
+        group: "navigation",
+        order: 1,
+        when: ( ContextKeyExpr.equals(SessionItemStatusContext.key, SessionStatus.NeedsInput))
+    }), MenuRegistry.appendMenuItem(Menus.BlockedSessionsItem, {
+        command: {
+            id: IGNORE_CI_FAILURE_COMMAND_ID,
+            title: ( localize(4507, "Ignore CI Failure")),
+            icon: Codicon.bellSlash
+        },
+        group: "navigation",
+        order: 1,
+        when: ( ContextKeyExpr.notEquals(SessionItemStatusContext.key, SessionStatus.NeedsInput))
+    }));
+}
+const BLOCKED_LIST_WIDTH = 360;
+const BLOCKED_LIST_MAX_VISIBLE_ROWS = 8;
+const BLOCKED_LIST_APPROVAL_ROW_MAX_LINES = 5;
+let BlockedSessionsList = class BlockedSessionsList extends Disposable {
+    constructor(container, options, instantiationService) {
+        super();
+        this._onDidChangeContentHeight = this._register(( new Emitter()));
+        this.onDidChangeContentHeight = this._onDidChangeContentHeight.event;
+        this._onDidApproveSession = this._register(( new Emitter()));
+        this.onDidApproveSession = this._onDidApproveSession.event;
+        this._width = options.width ?? BLOCKED_LIST_WIDTH;
+        const element = append(container, $(".agent-sessions-blocked-list"));
+        const header = append(element, $(".agent-sessions-blocked-list-header"));
+        const title = append(header, $(".agent-sessions-blocked-list-title"));
+        title.textContent = ( localize(4508, "Sessions requiring input"));
+        const headerActions = append(header, $(".agent-sessions-blocked-list-header-actions"));
+        this._register(
+            instantiationService.createInstance(MenuWorkbenchToolBar, headerActions, Menus.BlockedSessionsHeader, {
+                hiddenItemStrategy: HiddenItemStrategy.NoHide,
+                menuOptions: {
+                    arg: {
+                        showAllSessions: options.onShowAllSessions,
+                        ignoreAllSessions: () => {
+                            options.onIgnoreAllSessions();
+                            status(( localize(4509, "All current blocked sessions were ignored.")));
+                        },
+                        close: options.onClose
+                    }
+                },
+                toolbarOptions: {
+                    primaryGroup: () => true
+                },
+                telemetrySource: "blockedSessionsList.header"
+            })
+        );
+        this._rowsContainer = append(element, $(".agent-sessions-blocked-list-rows"));
+        this._list = this._register(
+            instantiationService.createInstance(SessionsFlatList, this._rowsContainer, {
+                showSessionHover: true,
+                onSessionOpen: options.onSessionOpen,
+                approvalModel: options.approvalModel,
+                ciFixModel: options.ciFixModel,
+                approvalRowMaxLines: BLOCKED_LIST_APPROVAL_ROW_MAX_LINES,
+                toolbarMenuId: Menus.BlockedSessionsItem,
+                onToolbarAction: (action, session) => {
+                    if (action.id !== IGNORE_INPUT_NEEDED_COMMAND_ID && action.id !== IGNORE_CI_FAILURE_COMMAND_ID) {
+                        return false;
+                    }
+                    options.onIgnoreSession(session);
+                    status(action.id === IGNORE_INPUT_NEEDED_COMMAND_ID ? ( localize(4510, "Input needed ignored until this session needs input again.")) : ( localize(4511, "CI failure ignored until this session has another CI failure.")));
+                    return true;
+                }
+            })
+        );
+        this._register(this._list.onDidChangeContentHeight(() => {
+            this._layout();
+            this._onDidChangeContentHeight.fire();
+        }));
+        this._register(
+            this._list.onDidApproveSession(approved => this._onDidApproveSession.fire(approved))
+        );
+    }
+    setSessions(sessions) {
+        this._list.setSessions(sessions);
+        this._layout();
+    }
+    focus() {
+        this._list.focus();
+    }
+    setWidth(width) {
+        if (this._width === width) {
+            return;
+        }
+        this._width = width;
+        this._layout();
+    }
+    _layout() {
+        const maxHeight = BLOCKED_LIST_MAX_VISIBLE_ROWS * this._list.getRowHeight();
+        const height = Math.min(this._list.getContentHeight(), maxHeight);
+        this._rowsContainer.style.width = `${this._width}px`;
+        this._rowsContainer.style.height = `${height}px`;
+        this._list.layout(height, this._width);
+    }
+};
+BlockedSessionsList = ( __decorate([( __param(2, IInstantiationService))], BlockedSessionsList));
+
+export { BlockedSessionsList, IGNORE_CI_FAILURE_COMMAND_ID, IGNORE_INPUT_NEEDED_COMMAND_ID, registerBlockedSessionsItemActions };