@codingame/monaco-vscode-katex-common 34.1.3 → 35.0.0

package/vscode/src/vs/workbench/contrib/chat/browser/widget/chatListWidget.d.ts

@@ -131,6 +131,7 @@ export declare class ChatListWidget extends Disposable {
      */
     get onDidFocusOutside(): Event<void>;
     private readonly _tree;
+    private readonly _delegate;
     private readonly _renderer;
     private _viewModel;
     private _visible;

package/vscode/src/vs/workbench/contrib/chat/browser/widget/chatListWidget.js

@@ -140,7 +140,7 @@ let ChatListWidget = class ChatListWidget extends Disposable {
             options.inputEditorBackground ?? "chat.requestEditor.background",
             options.resultEditorBackground ?? "chat.responseEditor.background"
         ));
-        const delegate = scopedInstantiationService.createInstance(ChatListDelegate, options.defaultElementHeight ?? 200);
+        this._delegate = scopedInstantiationService.createInstance(ChatListDelegate, options.defaultElementHeight ?? 200);
         const rendererDelegate = {
             getListLength: () => this._tree.getNode(null).visibleChildrenCount,
             onDidScroll: this.onDidScroll,
@@ -188,7 +188,7 @@ let ChatListWidget = class ChatListWidget extends Disposable {
             WorkbenchObjectTree,
             "ChatList",
             this._container,
-            delegate,
+            this._delegate,
             [this._renderer],
             {
                 identityProvider: {
@@ -312,6 +312,8 @@ let ChatListWidget = class ChatListWidget extends Disposable {
         const items = this._viewModel.getItems();
         this._lastItem = items.at(-1);
         this._lastItemIdContextKey.set(this._lastItem ? [this._lastItem.id] : []);
+        const previousItem = items.at(-2);
+        const needsInitialPreviousItemHeight = (isRequestVM(previousItem) || isResponseVM(previousItem)) && previousItem.currentRenderedHeight === undefined;
         const treeItems = ( items.map(item => ({
             element: item,
             collapsed: false,
@@ -337,6 +339,9 @@ let ChatListWidget = class ChatListWidget extends Disposable {
                 }
             });
         });
+        if (needsInitialPreviousItemHeight) {
+            this.updateLastItemMinHeight();
+        }
     }
     setScrollLock(value) {
         this._scrollLock = value;
@@ -511,7 +516,7 @@ let ChatListWidget = class ChatListWidget extends Disposable {
             const secondToLastItem = this._viewModel?.getItems().at(-2);
             const maxRequestShownHeight = 200;
             const secondToLastItemHeight = Math.min(
-                (isRequestVM(secondToLastItem) || isResponseVM(secondToLastItem)) ? secondToLastItem.currentRenderedHeight ?? 150 : 150,
+                (isRequestVM(secondToLastItem) || isResponseVM(secondToLastItem)) ? secondToLastItem.currentRenderedHeight ?? this._delegate.getMeasuredHeight(secondToLastItem) ?? 150 : 150,
                 maxRequestShownHeight
             );
             const lastItemMinHeight = Math.max(contentHeight - (secondToLastItemHeight + 10), 0);

package/vscode/src/vs/workbench/contrib/chat/browser/widget/chatRestoreCheckpointActionViewItem.d.ts

@@ -0,0 +1,32 @@
+import { IMenuEntryActionViewItemOptions, MenuEntryActionViewItem } from "@codingame/monaco-vscode-api/vscode/vs/platform/actions/browser/menuEntryActionViewItem";
+import { MenuItemAction } from "@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions";
+import { IAccessibilityService } from "@codingame/monaco-vscode-api/vscode/vs/platform/accessibility/common/accessibility.service";
+import { IContextKeyService } from "@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service";
+import { IContextMenuService } from "@codingame/monaco-vscode-api/vscode/vs/platform/contextview/browser/contextView.service";
+import { IKeybindingService } from "@codingame/monaco-vscode-api/vscode/vs/platform/keybinding/common/keybinding.service";
+import { INotificationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/notification/common/notification.service";
+import { IThemeService } from "@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/themeService.service";
+/**
+ * Action view item for the "Restore Checkpoint" action that adds an inline
+ * confirmation affordance: when the current request (and the requests after it)
+ * have edits that would be discarded, the first click does not restore but
+ * instead turns the button into a "Confirm" button with an adjacent "Cancel"
+ * button. A second click on "Confirm" runs the restore, while "Cancel" (or
+ * losing focus / pressing Escape) reverts the button to its default state.
+ *
+ * This gives a lightweight, in-place warning for sessions (such as agent host
+ * sessions) where the modal removal-confirmation dialog does not apply.
+ */
+export declare class ChatRestoreCheckpointActionViewItem extends MenuEntryActionViewItem {
+    private readonly _needsConfirmation;
+    private _confirming;
+    private _cancelButton;
+    private readonly _confirmDisposables;
+    constructor(action: MenuItemAction, options: IMenuEntryActionViewItemOptions | undefined, _needsConfirmation: (context: unknown) => boolean, keybindingService: IKeybindingService, notificationService: INotificationService, contextKeyService: IContextKeyService, themeService: IThemeService, contextMenuService: IContextMenuService, accessibilityService: IAccessibilityService);
+    render(container: HTMLElement): void;
+    onClick(event: MouseEvent): Promise<void>;
+    private _setConfirming;
+    private _updateConfirmUI;
+    protected updateLabel(): void;
+    protected getTooltip(): string;
+}

package/vscode/src/vs/workbench/contrib/chat/browser/widget/chatRestoreCheckpointActionViewItem.js

@@ -0,0 +1,135 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { append, $, reset, addDisposableListener, EventType, EventHelper } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { StandardKeyboardEvent } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/keyboardEvent';
+import { renderLabelWithIcons } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/iconLabel/iconLabels';
+import { KeyCode } from '@codingame/monaco-vscode-api/vscode/vs/base/common/keyCodes';
+import { DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { MenuEntryActionViewItem } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/browser/menuEntryActionViewItem';
+import { IAccessibilityService } from '@codingame/monaco-vscode-api/vscode/vs/platform/accessibility/common/accessibility.service';
+import { IContextKeyService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service';
+import { IContextMenuService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextview/browser/contextView.service';
+import { IKeybindingService } from '@codingame/monaco-vscode-api/vscode/vs/platform/keybinding/common/keybinding.service';
+import { INotificationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/notification/common/notification.service';
+import { IThemeService } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/themeService.service';
+
+let ChatRestoreCheckpointActionViewItem = class ChatRestoreCheckpointActionViewItem extends MenuEntryActionViewItem {
+    constructor(
+        action,
+        options,
+        _needsConfirmation,
+        keybindingService,
+        notificationService,
+        contextKeyService,
+        themeService,
+        contextMenuService,
+        accessibilityService
+    ) {
+        super(
+            action,
+            options,
+            keybindingService,
+            notificationService,
+            contextKeyService,
+            themeService,
+            contextMenuService,
+            accessibilityService
+        );
+        this._needsConfirmation = _needsConfirmation;
+        this._confirming = false;
+        this._confirmDisposables = this._register(( new DisposableStore()));
+    }
+    render(container) {
+        super.render(container);
+        container.classList.add("chat-restore-checkpoint-item");
+        const cancelButton = this._cancelButton = append(container, $("a.action-label.chat-restore-checkpoint-cancel"));
+        cancelButton.setAttribute("role", "button");
+        cancelButton.tabIndex = -1;
+        reset(cancelButton, ...renderLabelWithIcons(`$(close)`));
+        const cancelLabel = ( localize(8211, "Cancel restoring this checkpoint"));
+        cancelButton.title = cancelLabel;
+        cancelButton.setAttribute("aria-label", cancelLabel);
+        this._register(addDisposableListener(cancelButton, EventType.CLICK, e => {
+            EventHelper.stop(e, true);
+            this._setConfirming(false);
+            this.label?.focus();
+        }));
+        this._register(addDisposableListener(container, EventType.KEY_DOWN, e => {
+            const event = ( new StandardKeyboardEvent(e));
+            if (!event.equals(KeyCode.Enter) && !event.equals(KeyCode.Space)) {
+                return;
+            }
+            if (this._confirming) {
+                EventHelper.stop(e, true);
+                this._setConfirming(false);
+                void super.onClick(( new MouseEvent("click")));
+                return;
+            }
+            if (this._needsConfirmation(this._context)) {
+                EventHelper.stop(e, true);
+                this._setConfirming(true);
+            }
+        }));
+        this._updateConfirmUI();
+    }
+    async onClick(event) {
+        if (this._confirming) {
+            this._setConfirming(false);
+            return super.onClick(event);
+        }
+        if (this._needsConfirmation(this._context)) {
+            event.preventDefault();
+            event.stopPropagation();
+            this._setConfirming(true);
+            return;
+        }
+        return super.onClick(event);
+    }
+    _setConfirming(value) {
+        if (this._confirming === value) {
+            return;
+        }
+        this._confirming = value;
+        this._confirmDisposables.clear();
+        if (value && this.element) {
+            this._confirmDisposables.add(addDisposableListener(this.element, EventType.FOCUS_OUT, e => {
+                const next = e.relatedTarget;
+                if (!next || !this.element?.contains(next)) {
+                    this._setConfirming(false);
+                }
+            }));
+            this._confirmDisposables.add(addDisposableListener(this.element, EventType.KEY_DOWN, e => {
+                const event = ( new StandardKeyboardEvent(e));
+                if (event.equals(KeyCode.Escape)) {
+                    EventHelper.stop(e, true);
+                    this._setConfirming(false);
+                    this.label?.focus();
+                }
+            }));
+        }
+        this._updateConfirmUI();
+    }
+    _updateConfirmUI() {
+        this.element?.classList.toggle("confirming", this._confirming);
+        this._cancelButton?.classList.toggle("hidden", !this._confirming);
+        this.updateLabel();
+        this.updateTooltip();
+    }
+    updateLabel() {
+        if (this._confirming && this.label) {
+            reset(this.label, ...renderLabelWithIcons(`${( localize(8212, "Discard Edits"))}`));
+            return;
+        }
+        super.updateLabel();
+    }
+    getTooltip() {
+        if (this._confirming) {
+            return localize(8213, "Confirm restoring this checkpoint and discarding later edits");
+        }
+        return super.getTooltip();
+    }
+};
+ChatRestoreCheckpointActionViewItem = ( __decorate([( __param(3, IKeybindingService)), ( __param(4, INotificationService)), ( __param(5, IContextKeyService)), ( __param(6, IThemeService)), ( __param(7, IContextMenuService)), ( __param(8, IAccessibilityService))], ChatRestoreCheckpointActionViewItem));
+
+export { ChatRestoreCheckpointActionViewItem };

package/vscode/src/vs/workbench/contrib/chat/browser/widget/chatTurnPills.d.ts

@@ -0,0 +1,85 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IObservable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/observable";
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { ICommandService } from "@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands.service";
+import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+import { IContextMenuService } from "@codingame/monaco-vscode-api/vscode/vs/platform/contextview/browser/contextView.service";
+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 { IOpenerService } from "@codingame/monaco-vscode-api/vscode/vs/platform/opener/common/opener.service";
+/** Aggregate diff counts shown in the changes pill (scoped to a single turn). */
+export interface IDiffStats {
+    readonly files: number;
+    readonly insertions: number;
+    readonly deletions: number;
+}
+export declare const EMPTY_DIFF_STATS: IDiffStats;
+/** A markdown/HTML file the preview pill can open. */
+export interface IPreviewFile {
+    readonly uri: URI;
+    readonly kind: "markdown" | "html";
+    /** Whether the file was created (vs. edited) during the turn. */
+    readonly created: boolean;
+}
+/** Classify a resource as a previewable markdown or HTML file, if applicable. */
+export declare function previewKind(uri: URI): "markdown" | "html" | undefined;
+export declare function diffStatsEqual(a: IDiffStats, b: IDiffStats): boolean;
+export declare function previewFilesEqual(a: readonly IPreviewFile[], b: readonly IPreviewFile[]): boolean;
+/**
+ * Open a previewable file: markdown files open as a markdown preview, HTML files
+ * open in the integrated browser (desktop only), falling back to the default
+ * opener when neither is available (e.g. web).
+ */
+export declare function openChatPreviewFile(file: IPreviewFile, commandService: ICommandService, openerService: IOpenerService, logService: ILogService): Promise<void>;
+/** The data and interactions a {@link ChatTurnPillsWidget} reflects. */
+export interface IChatTurnPillsModel {
+    readonly stats: IObservable<IDiffStats>;
+    readonly previewFiles: IObservable<readonly IPreviewFile[]>;
+    /** When `false` the changes pill stays hidden regardless of the data. */
+    readonly changesEnabled: IObservable<boolean>;
+    /** When `false` the preview pill stays hidden regardless of the data. */
+    readonly previewEnabled: IObservable<boolean>;
+    openChanges(): void;
+    openPreviewFile(file: IPreviewFile): void;
+}
+/** Per-pill visibility for the agent turn status pills ({@link ChatConfiguration.TurnStatusPills}). */
+export interface IChatTurnStatusPillsConfig {
+    readonly changes: boolean;
+    readonly preview: boolean;
+}
+/** Observe the per-pill turn status pills visibility setting. */
+export declare function observeTurnStatusPillsConfig(configurationService: IConfigurationService): IObservable<IChatTurnStatusPillsConfig>;
+/**
+ * A toolbar of clickable pills reflecting a single turn's status. Used both as a
+ * floating widget above the chat input (live, active turn) and inside a completed
+ * chat response. The pills are actions inside a {@link ToolBar}:
+ *
+ * - **Changes** — `<n> Files +ins -del` for the turn. Activating it opens the
+ *   changes.
+ * - **Preview** — shown when the turn created or edited a markdown or HTML file.
+ *   Rendered as a resource label (file icon + name) with a "preview" description
+ *   for the primary file. Activating it opens that file as a markdown preview or
+ *   in the integrated browser; when several exist, a dropdown lists them all.
+ *
+ * The data and the open actions are supplied by the {@link IChatTurnPillsModel}
+ * so the same widget serves surfaces with different data sources.
+ */
+export declare class ChatTurnPillsWidget extends Disposable {
+    private readonly _model;
+    private readonly _contextMenuService;
+    readonly element: HTMLElement;
+    /** Whether the widget currently has any pill to show. */
+    readonly isVisible: IObservable<boolean>;
+    private readonly _toolbar;
+    private readonly _changesAction;
+    private readonly _previewAction;
+    private readonly _resourceLabels;
+    /** Ids of the currently mounted pills, so we only rebuild the toolbar when the set changes. */
+    private _visibleSignature;
+    constructor(_model: IChatTurnPillsModel, _contextMenuService: IContextMenuService, instantiationService: IInstantiationService);
+    private _showChanges;
+    private _showPreview;
+    private _updateVisibleActions;
+    private _openPrimaryPreview;
+    private _showAllPreviews;
+}

package/vscode/src/vs/workbench/contrib/chat/browser/widget/chatTurnPills.js

@@ -0,0 +1,275 @@
+
+import { registerCss } from '@codingame/monaco-vscode-api/css';
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { reset, $, append } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { ActionsOrientation } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/actionbar/actionbar';
+import { BaseActionViewItem } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/actionbar/actionViewItems';
+import { Button } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/button/button';
+import { ToolBar } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/toolbar/toolbar';
+import { Action, toAction } from '@codingame/monaco-vscode-api/vscode/vs/base/common/actions';
+import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { isEqual, basename } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { ThemeIcon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/themables';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { BrowserViewCommandId } from '@codingame/monaco-vscode-api/vscode/vs/platform/browserView/common/browserView';
+import { IContextMenuService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextview/browser/contextView.service';
+import { FileKind } from '@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { observableConfigValue } from '@codingame/monaco-vscode-api/vscode/vs/platform/observable/common/platformObservableUtils';
+import { defaultButtonStyles } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/browser/defaultStyles';
+import { ResourceLabels, DEFAULT_LABELS_CONTAINER } from '@codingame/monaco-vscode-api/vscode/vs/workbench/browser/labels';
+import { ChatConfiguration } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
+import * as chatTurnPills from '../media/chatTurnPills.css';
+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';
+
+registerCss(chatTurnPills);
+const CHANGES_PILL_ACTION_ID = "chat.turnPills.changes";
+const PREVIEW_PILL_ACTION_ID = "chat.turnPills.preview";
+const TRANSPARENT_BUTTON_STYLES = {
+    buttonBackground: undefined,
+    buttonHoverBackground: undefined,
+    buttonForeground: undefined,
+    buttonSeparator: undefined,
+    buttonSecondaryBackground: undefined,
+    buttonSecondaryHoverBackground: undefined,
+    buttonSecondaryForeground: undefined,
+    buttonSecondaryBorder: undefined,
+    buttonBorder: undefined
+};
+const EMPTY_DIFF_STATS = {
+    files: 0,
+    insertions: 0,
+    deletions: 0
+};
+function previewKind(uri) {
+    const path = uri.path.toLowerCase();
+    if (path.endsWith(".md") || path.endsWith(".markdown")) {
+        return "markdown";
+    }
+    if (path.endsWith(".html") || path.endsWith(".htm")) {
+        return "html";
+    }
+    return undefined;
+}
+function diffStatsEqual(a, b) {
+    return a.files === b.files && a.insertions === b.insertions && a.deletions === b.deletions;
+}
+function previewFilesEqual(a, b) {
+    if (a.length !== b.length) {
+        return false;
+    }
+    for (let i = 0; i < a.length; i++) {
+        if (a[i].kind !== b[i].kind || a[i].created !== b[i].created || !isEqual(a[i].uri, b[i].uri)) {
+            return false;
+        }
+    }
+    return true;
+}
+async function openChatPreviewFile(file, commandService, openerService, logService) {
+    try {
+        if (file.kind === "markdown") {
+            await commandService.executeCommand("markdown.showPreview", file.uri);
+        } else {
+            await commandService.executeCommand(BrowserViewCommandId.Open, ( file.uri.toString()));
+        }
+    } catch (err) {
+        logService.trace("[ChatTurnPills] Falling back to default opener for preview", err);
+        await openerService.open(file.uri);
+    }
+}
+const TURN_STATUS_PILLS_DEFAULT = {
+    changes: false,
+    preview: false
+};
+function observeTurnStatusPillsConfig(configurationService) {
+    return observableConfigValue(
+        ChatConfiguration.TurnStatusPills,
+        TURN_STATUS_PILLS_DEFAULT,
+        configurationService
+    );
+}
+class ChangesPillActionViewItem extends BaseActionViewItem {
+    constructor(action, options, _statsObs) {
+        super(undefined, action, options);
+        this._statsObs = _statsObs;
+    }
+    render(container) {
+        this.element = container;
+        container.classList.add("chat-turn-pill-changes");
+        const button = this._button = this._register(( new Button(container, {
+            secondary: true,
+            small: true,
+            ...defaultButtonStyles
+        })));
+        button.element.classList.add("monaco-text-button", "chat-turn-pill-changes-button");
+        this._register(button.onDidClick(() => {
+            if (this._action.enabled) {
+                this.actionRunner.run(this._action, this._context);
+            }
+        }));
+        this._register(autorun(reader => {
+            this._statsObs.read(reader);
+            this._updateLabel();
+        }));
+    }
+    _updateLabel() {
+        if (!this._button) {
+            return;
+        }
+        const {
+            files,
+            insertions,
+            deletions
+        } = this._statsObs.get();
+        const filesLabel = files === 1 ? ( localize(8214, "{0} File", files)) : ( localize(8215, "{0} Files", files));
+        reset(this._button.element, $(
+            `span.chat-turn-pill-meta-icon${ThemeIcon.asCSSSelector(Codicon.diffMultiple)}`
+        ), $("span.chat-turn-pill-meta-label", undefined, filesLabel), $("span.chat-turn-pill-meta-added", undefined, `+${insertions}`), $("span.chat-turn-pill-meta-removed", undefined, `-${deletions}`));
+        this._button.setTitle(( localize(8216, "View Changes")));
+        this._button.element.setAttribute("aria-label", ( localize(8217, "View Changes: {0}, +{1}, -{2}", filesLabel, insertions, deletions)));
+    }
+    focus() {
+        this._button?.focus();
+    }
+}
+class PreviewPillActionViewItem extends BaseActionViewItem {
+    constructor(action, options, _previewFilesObs, _resourceLabels, _openFile, _showAll) {
+        super(undefined, action, options);
+        this._previewFilesObs = _previewFilesObs;
+        this._resourceLabels = _resourceLabels;
+        this._openFile = _openFile;
+        this._showAll = _showAll;
+    }
+    render(container) {
+        this.element = container;
+        container.classList.add("chat-turn-pill-preview");
+        const primary = this._primary = this._register(( new Button(container, {
+            ...TRANSPARENT_BUTTON_STYLES
+        })));
+        primary.element.classList.add("chat-turn-pill-preview-primary");
+        const label = this._register(this._resourceLabels.create(primary.element));
+        this._register(primary.onDidClick(() => {
+            const primaryFile = this._previewFilesObs.get().at(0);
+            if (primaryFile) {
+                this._openFile(primaryFile);
+            }
+        }));
+        const separator = append(container, $(".chat-turn-pill-preview-separator"));
+        const chevron = this._register(( new Button(container, {
+            ...TRANSPARENT_BUTTON_STYLES
+        })));
+        chevron.element.classList.add("chat-turn-pill-preview-chevron");
+        append(chevron.element, $(`span${ThemeIcon.asCSSSelector(Codicon.chevronDown)}`));
+        const moreLabel = ( localize(8218, "Show All Previewable Files"));
+        chevron.setTitle(moreLabel);
+        chevron.setAriaLabel(moreLabel);
+        this._register(chevron.onDidClick(() => this._showAll(chevron.element)));
+        this._register(autorun(reader => {
+            const files = this._previewFilesObs.read(reader);
+            const primaryFile = files.at(0);
+            if (primaryFile) {
+                label.setResource({
+                    resource: primaryFile.uri,
+                    name: basename(primaryFile.uri),
+                    description: ( localize(8219, "preview"))
+                }, {
+                    fileKind: FileKind.FILE
+                });
+                const tooltip = ( localize(8220, "Open Preview: {0}", basename(primaryFile.uri)));
+                primary.setTitle(tooltip);
+                primary.setAriaLabel(tooltip);
+            }
+            const hasMultiple = files.length > 1;
+            separator.classList.toggle("hidden", !hasMultiple);
+            chevron.element.classList.toggle("hidden", !hasMultiple);
+        }));
+    }
+    focus() {
+        this._primary?.focus();
+    }
+}
+let ChatTurnPillsWidget = class ChatTurnPillsWidget extends Disposable {
+    constructor(_model, _contextMenuService, instantiationService) {
+        super();
+        this._model = _model;
+        this._contextMenuService = _contextMenuService;
+        this.element = $(".chat-turn-pills.show-file-icons.hidden");
+        this._resourceLabels = this._register(
+            instantiationService.createInstance(ResourceLabels, DEFAULT_LABELS_CONTAINER)
+        );
+        this._changesAction = this._register(( new Action(CHANGES_PILL_ACTION_ID, ( localize(8216, "View Changes")), undefined, true, async () => this._model.openChanges())));
+        this._previewAction = this._register(( new Action(PREVIEW_PILL_ACTION_ID, ( localize(8221, "Open Preview")), undefined, true, async () => this._openPrimaryPreview())));
+        this._toolbar = this._register(( new ToolBar(this.element, this._contextMenuService, {
+            orientation: ActionsOrientation.HORIZONTAL,
+            ariaLabel: ( localize(8222, "Turn status")),
+            actionViewItemProvider: (action, options) => {
+                if (action.id === CHANGES_PILL_ACTION_ID) {
+                    return ( new ChangesPillActionViewItem(action, options, this._model.stats));
+                }
+                if (action.id === PREVIEW_PILL_ACTION_ID) {
+                    return ( new PreviewPillActionViewItem(
+                        action,
+                        options,
+                        this._model.previewFiles,
+                        this._resourceLabels,
+                        file => this._model.openPreviewFile(file),
+                        anchor => this._showAllPreviews(anchor)
+                    ));
+                }
+                return undefined;
+            }
+        })));
+        this.isVisible = derived(this, reader => this._showChanges(reader) || this._showPreview(reader));
+        this._register(autorun(reader => {
+            this._updateVisibleActions(this._showChanges(reader), this._showPreview(reader));
+        }));
+    }
+    _showChanges(reader) {
+        return this._model.changesEnabled.read(reader) && this._model.stats.read(reader).files > 0;
+    }
+    _showPreview(reader) {
+        return this._model.previewEnabled.read(reader) && this._model.previewFiles.read(reader).length > 0;
+    }
+    _updateVisibleActions(showChanges, showPreview) {
+        const actions = [];
+        if (showChanges) {
+            actions.push(this._changesAction);
+        }
+        if (showPreview) {
+            actions.push(this._previewAction);
+        }
+        const signature = ( actions.map(a => a.id)).join(",");
+        if (signature !== this._visibleSignature) {
+            this._visibleSignature = signature;
+            this._toolbar.setActions(actions);
+        }
+        this.element.classList.toggle("hidden", actions.length === 0);
+    }
+    _openPrimaryPreview() {
+        const primaryFile = this._model.previewFiles.get().at(0);
+        if (primaryFile) {
+            this._model.openPreviewFile(primaryFile);
+        }
+    }
+    _showAllPreviews(anchor) {
+        const files = this._model.previewFiles.get();
+        if (files.length === 0) {
+            return;
+        }
+        this._contextMenuService.showContextMenu({
+            getAnchor: () => anchor,
+            getActions: () => ( files.map(file => toAction({
+                id: `${PREVIEW_PILL_ACTION_ID}.${( file.uri.toString())}`,
+                label: basename(file.uri),
+                class: ThemeIcon.asClassName(file.kind === "html" ? Codicon.globe : Codicon.openPreview),
+                run: () => this._model.openPreviewFile(file)
+            })))
+        });
+    }
+};
+ChatTurnPillsWidget = ( __decorate([( __param(1, IContextMenuService)), ( __param(2, IInstantiationService))], ChatTurnPillsWidget));
+
+export { ChatTurnPillsWidget, EMPTY_DIFF_STATS, diffStatsEqual, observeTurnStatusPillsConfig, openChatPreviewFile, previewFilesEqual, previewKind };

package/vscode/src/vs/workbench/contrib/chat/browser/widget/chatWidget.d.ts

@@ -158,12 +158,16 @@ export declare class ChatWidget extends Disposable implements IChatWidget {
     private agentInInput;
     private _visible;
     get visible(): boolean;
+    private _inputVisible;
     private _instructionFilesCheckPromise;
     private _instructionFilesExist;
     private _isRenderingWelcome;
     private _lockedAgent?;
     private readonly _lockedToCodingAgentContextKey;
     private readonly _lockedCodingAgentIdContextKey;
+    private readonly _readOnlyContextKey;
+    private readonly _chatIsAgentHostSessionContextKey;
+    private readonly _chatAgentHostProviderIdContextKey;
     private readonly _chatSessionSupportsForkContextKey;
     private readonly _agentSupportsAttachmentsContextKey;
     private readonly _sessionIsEmptyContextKey;
@@ -257,6 +261,19 @@ export declare class ChatWidget extends Disposable implements IChatWidget {
      */
     private _handleDelegationExit;
     private archiveLocalParentSession;
+    /**
+     * Mark the chat shown in this widget as read-only (non-interactive) or not.
+     * Read-only chats hide the composer and expose a context key so mutating
+     * actions (e.g. Start Over, Restore Checkpoint) are not offered.
+     */
+    setReadOnly(readOnly: boolean): void;
+    /**
+     * Show or hide the input part. Hidden inputs are removed from the DOM flow
+     * and not reserved during layout so the message list takes the full height.
+     * Used to render read-only (non-interactive) chats without a composer.
+     */
+    setInputVisible(visible: boolean): void;
+    private _applyInputVisibility;
     setVisible(visible: boolean): void;
     private createList;
     startEditing(requestId: string): void;
@@ -282,7 +299,7 @@ export declare class ChatWidget extends Disposable implements IChatWidget {
     setInput(value?: string): void;
     getInput(): string;
     getContrib<T extends IChatWidgetContrib>(id: string): T | undefined;
-    lockToCodingAgent(name: string, displayName: string, agentId: string): void;
+    lockToCodingAgent(name: string, displayName: string, agentId: string, agentHostProviderId?: string): void;
     unlockFromCodingAgent(): void;
     get isLockedToCodingAgent(): boolean;
     get lockedAgentId(): string | undefined;