@codingame/monaco-vscode-katex-common 30.0.1 → 31.0.0

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

@@ -0,0 +1,425 @@
+
+import { registerCss } from '@codingame/monaco-vscode-api/css';
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { h, DisposableResizeObserver, hide, clearNode, append, $, addDisposableListener, EventType, show } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { StandardKeyboardEvent } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/keyboardEvent';
+import { Button, ButtonWithDropdown } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/button/button';
+import { DomScrollableElement } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/scrollbar/scrollableElement';
+import { Action } from '@codingame/monaco-vscode-api/vscode/vs/base/common/actions';
+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 { MarkdownString } from '@codingame/monaco-vscode-api/vscode/vs/base/common/htmlContent';
+import { KeyCode } from '@codingame/monaco-vscode-api/vscode/vs/base/common/keyCodes';
+import { Disposable, DisposableStore, MutableDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { ScrollbarVisibility } from '@codingame/monaco-vscode-api/vscode/vs/base/common/scrollable';
+import Severity from '@codingame/monaco-vscode-api/vscode/vs/base/common/severity';
+import { basename } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { generateUuid } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uuid';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { IContextMenuService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextview/browser/contextView.service';
+import { IDialogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/dialogs/common/dialogs.service';
+import { IHoverService } from '@codingame/monaco-vscode-api/vscode/vs/platform/hover/browser/hover.service';
+import { IMarkdownRendererService } from '@codingame/monaco-vscode-api/vscode/vs/platform/markdown/browser/markdownRenderer.service';
+import { defaultButtonStyles } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/browser/defaultStyles';
+import { IEditorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service';
+import { ChatPlanReviewData } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/chatProgressTypes/chatPlanReviewData';
+import { isResponseVM } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/chatViewModel';
+import * as chatPlanReview from './media/chatPlanReview.css';
+
+registerCss(chatPlanReview);
+let ChatPlanReviewPart = class ChatPlanReviewPart extends Disposable {
+    constructor(
+        review,
+        context,
+        _options,
+        _markdownRendererService,
+        _contextMenuService,
+        _dialogService,
+        _editorService,
+        _hoverService
+    ) {
+        super();
+        this.review = review;
+        this._options = _options;
+        this._markdownRendererService = _markdownRendererService;
+        this._contextMenuService = _contextMenuService;
+        this._dialogService = _dialogService;
+        this._editorService = _editorService;
+        this._hoverService = _hoverService;
+        this._onDidChangeHeight = this._register(( new Emitter()));
+        this.onDidChangeHeight = this._onDidChangeHeight.event;
+        this._buttonStore = this._register(( new DisposableStore()));
+        this._messageContentDisposables = this._register(( new MutableDisposable()));
+        this._isCollapsed = false;
+        this._isExpanded = false;
+        this._isSubmitted = false;
+        this._isFeedbackMode = false;
+        this._selectedAction = review.actions.find(a => a.default) ?? review.actions[0];
+        if (review instanceof ChatPlanReviewData && typeof review.draftCollapsed === "boolean") {
+            this._isCollapsed = review.draftCollapsed;
+        }
+        const isResponseComplete = isResponseVM(context.element) && context.element.isComplete;
+        this._isSubmitted = !!review.isUsed || isResponseComplete;
+        const elements = h(
+            ".chat-confirmation-widget-container.chat-plan-review-container@container",
+            [h(
+                ".chat-confirmation-widget2.chat-plan-review@root",
+                [h(".chat-confirmation-widget-title.chat-plan-review-title@title", [
+                    h(".chat-plan-review-title-label@titleLabel"),
+                    h(".chat-plan-review-inline-actions@inlineActions"),
+                    h(".chat-plan-review-title-actions@titleActions")
+                ]), h(".chat-confirmation-widget-message.chat-plan-review-body@message"), h(".chat-plan-review-feedback@feedback"), h(
+                    ".chat-confirmation-widget-buttons.chat-plan-review-footer",
+                    [h(".chat-buttons@footerButtons")]
+                )]
+            )]
+        );
+        this.domNode = elements.container;
+        this.domNode.id = generateUuid();
+        this.domNode.setAttribute("role", "region");
+        this.domNode.setAttribute("aria-label", ( localize(6855, "Plan review: {0}", review.title)));
+        this._titleActionsEl = elements.titleActions;
+        this._inlineActionsEl = elements.inlineActions;
+        this._footerButtonsEl = elements.footerButtons;
+        this._messageEl = elements.message;
+        elements.titleLabel.textContent = review.title;
+        this._register(this._hoverService.setupDelayedHover(elements.titleLabel, {
+            content: review.title
+        }));
+        if (review.planUri) {
+            const fileName = basename(URI.revive(review.planUri));
+            const editButton = this._register(( new Button(this._titleActionsEl, {
+                ...defaultButtonStyles,
+                secondary: true,
+                supportIcons: true,
+                title: ( localize(6856, "Edit {0}", fileName))
+            })));
+            editButton.element.classList.add("chat-plan-review-title-button", "chat-plan-review-edit");
+            editButton.label = `$(${Codicon.edit.id}) ${( localize(6857, "Edit {0}", fileName))}`;
+            this._register(editButton.onDidClick(() => this.openPlanFile()));
+        }
+        this._restoreButton = this._register(( new Button(this._titleActionsEl, {
+            ...defaultButtonStyles,
+            secondary: true,
+            supportIcons: true
+        })));
+        this._restoreButton.element.classList.add("chat-plan-review-title-button", "chat-plan-review-title-icon-button");
+        this._register(this._restoreButton.onDidClick(() => this.toggleExpanded()));
+        this._collapseButton = this._register(( new Button(this._titleActionsEl, {
+            ...defaultButtonStyles,
+            secondary: true,
+            supportIcons: true
+        })));
+        this._collapseButton.element.classList.add("chat-plan-review-title-button", "chat-plan-review-title-icon-button");
+        this._register(this._collapseButton.onDidClick(() => this.toggleCollapsed()));
+        const messageParent = this._messageEl.parentElement;
+        const messageNextSibling = this._messageEl.nextSibling;
+        this._messageScrollable = this._register(( new DomScrollableElement(this._messageEl, {
+            vertical: ScrollbarVisibility.Auto,
+            horizontal: ScrollbarVisibility.Hidden,
+            consumeMouseWheelIfScrollbarIsNeeded: true
+        })));
+        this._messageScrollable.getDomNode().classList.add(
+            "chat-confirmation-widget-message-scrollable",
+            "chat-plan-review-body-scrollable"
+        );
+        messageParent.insertBefore(this._messageScrollable.getDomNode(), messageNextSibling);
+        const resizeObserver = this._register(
+            new DisposableResizeObserver(() => this._messageScrollable.scanDomNode())
+        );
+        this._register(resizeObserver.observe(this._messageEl));
+        this._register(resizeObserver.observe(this._messageScrollable.getDomNode()));
+        this.renderMarkdown();
+        if (review.canProvideFeedback) {
+            this.renderFeedback(elements.feedback);
+            this._feedbackSection = elements.feedback;
+            hide(elements.feedback);
+        } else {
+            hide(elements.feedback);
+        }
+        this.renderActionButtons(this._isCollapsed ? this._inlineActionsEl : this._footerButtonsEl, {
+            includeReject: !this._isCollapsed
+        });
+        this.updateCollapsedPresentation();
+        this.updateExpandedPresentation();
+        if (this._isSubmitted) {
+            this.domNode.classList.add("chat-plan-review-used");
+        }
+        if (this._feedbackTextarea && review instanceof ChatPlanReviewData && review.draftFeedback) {
+            this._feedbackTextarea.value = review.draftFeedback;
+        }
+    }
+    hasSameContent(other, _followingContent, _element) {
+        if (other.kind !== "planReview") {
+            return false;
+        }
+        if (!!other.isUsed !== !!this.review.isUsed) {
+            return false;
+        }
+        if (this.review.resolveId && other.resolveId) {
+            return this.review.resolveId === other.resolveId;
+        }
+        return other === this.review;
+    }
+    renderMarkdown() {
+        clearNode(this._messageEl);
+        const store = ( new DisposableStore());
+        const rendered = store.add(this._markdownRendererService.render(( new MarkdownString(this.review.content, {
+            supportThemeIcons: true,
+            isTrusted: false
+        })), {
+            asyncRenderCallback: () => this._messageScrollable.scanDomNode()
+        }));
+        this._messageEl.append(rendered.element);
+        this._messageContentDisposables.value = store;
+        this._messageScrollable.scanDomNode();
+    }
+    renderFeedback(section) {
+        clearNode(section);
+        const label = append(section, $(".chat-plan-review-feedback-label"));
+        label.textContent = ( localize(6858, "Additional feedback"));
+        const textarea = append(section, $("textarea.chat-plan-review-feedback-textarea"));
+        textarea.rows = 1;
+        textarea.placeholder = ( localize(6859, "Suggest changes or add instructions..."));
+        this._feedbackTextarea = textarea;
+        const autoResize = () => {
+            textarea.style.height = "auto";
+            textarea.style.height = `${textarea.scrollHeight}px`;
+            this._onDidChangeHeight.fire();
+        };
+        this._register(addDisposableListener(textarea, EventType.INPUT, () => {
+            autoResize();
+            if (this.review instanceof ChatPlanReviewData) {
+                this.review.draftFeedback = textarea.value;
+            }
+        }));
+        this._register(addDisposableListener(textarea, EventType.KEY_DOWN, e => {
+            const ev = ( new StandardKeyboardEvent(e));
+            if (ev.keyCode === KeyCode.Enter && !ev.shiftKey) {
+                e.preventDefault();
+                e.stopPropagation();
+                this.submitFeedback();
+            }
+        }));
+    }
+    renderActionButtons(container, options) {
+        const includeReject = options?.includeReject ?? true;
+        this._buttonStore.clear();
+        clearNode(container);
+        if (this._isFeedbackMode) {
+            const submitButton = ( new Button(container, {
+                ...defaultButtonStyles,
+                supportIcons: true
+            }));
+            submitButton.label = ( localize(6860, "Submit"));
+            this._buttonStore.add(submitButton);
+            this._buttonStore.add(submitButton.onDidClick(() => this.submitFeedback()));
+            if (includeReject) {
+                const rejectButton = ( new Button(container, {
+                    ...defaultButtonStyles,
+                    secondary: true
+                }));
+                rejectButton.label = ( localize(6861, "Reject"));
+                this._buttonStore.add(rejectButton);
+                this._buttonStore.add(rejectButton.onDidClick(() => this.submitRejection()));
+            }
+            return;
+        }
+        const primary = this._selectedAction;
+        const moreActions = this.review.actions.filter(a => a !== primary);
+        let approveButton;
+        if (moreActions.length > 0) {
+            approveButton = ( new ButtonWithDropdown(container, {
+                ...defaultButtonStyles,
+                supportIcons: true,
+                contextMenuProvider: this._contextMenuService,
+                addPrimaryActionToDropdown: false,
+                actions: ( moreActions.map(action => {
+                    const button = ( new Action(action.label, action.label, undefined, true, () => {
+                        this.submitApproval(action);
+                        return Promise.resolve();
+                    }));
+                    button.tooltip = action.description || "";
+                    return this._buttonStore.add(button);
+                }))
+            }));
+        } else {
+            approveButton = ( new Button(container, {
+                ...defaultButtonStyles,
+                supportIcons: true
+            }));
+        }
+        this._buttonStore.add(approveButton);
+        approveButton.label = primary.label;
+        if (primary.description) {
+            approveButton.element.title = primary.description;
+        }
+        this._buttonStore.add(approveButton.onDidClick(() => this.submitApproval(primary)));
+        if (this.review.canProvideFeedback && includeReject) {
+            const feedbackButton = ( new Button(container, {
+                ...defaultButtonStyles,
+                secondary: true
+            }));
+            feedbackButton.label = ( localize(6862, "Provide Feedback"));
+            this._buttonStore.add(feedbackButton);
+            this._buttonStore.add(feedbackButton.onDidClick(() => this.enterFeedbackMode()));
+        }
+        if (includeReject) {
+            const rejectButton = ( new Button(container, {
+                ...defaultButtonStyles,
+                secondary: true
+            }));
+            rejectButton.label = ( localize(6861, "Reject"));
+            this._buttonStore.add(rejectButton);
+            this._buttonStore.add(rejectButton.onDidClick(() => this.submitRejection()));
+        }
+    }
+    toggleCollapsed() {
+        this._isCollapsed = !this._isCollapsed;
+        if (this._isCollapsed) {
+            this._isExpanded = false;
+        }
+        if (this.review instanceof ChatPlanReviewData) {
+            this.review.draftCollapsed = this._isCollapsed;
+        }
+        this.updateCollapsedPresentation();
+        this.updateExpandedPresentation();
+        this._onDidChangeHeight.fire();
+    }
+    toggleExpanded() {
+        if (this._isCollapsed) {
+            this._isCollapsed = false;
+            this.updateCollapsedPresentation();
+        }
+        this._isExpanded = !this._isExpanded;
+        this.updateExpandedPresentation();
+        this._onDidChangeHeight.fire();
+    }
+    updateCollapsedPresentation() {
+        this.domNode.classList.toggle("chat-plan-review-collapsed", this._isCollapsed);
+        this._restoreButton.element.classList.toggle("chat-plan-review-hidden", this._isCollapsed);
+        this._collapseButton.label = this._isCollapsed ? `$(${Codicon.chevronDown.id})` : `$(${Codicon.chevronUp.id})`;
+        const collapseTooltip = this._isCollapsed ? ( localize(6863, "Expand")) : ( localize(6864, "Collapse"));
+        this._collapseButton.element.setAttribute("aria-label", collapseTooltip);
+        this._collapseButton.element.setAttribute("aria-expanded", String(!this._isCollapsed));
+        this._collapseButton.setTitle(collapseTooltip);
+        if (!this._isSubmitted) {
+            if (this._isCollapsed && this._isFeedbackMode) {
+                this._isFeedbackMode = false;
+                if (this._feedbackSection) {
+                    hide(this._feedbackSection);
+                }
+            }
+            const target = this._isCollapsed ? this._inlineActionsEl : this._footerButtonsEl;
+            const other = this._isCollapsed ? this._footerButtonsEl : this._inlineActionsEl;
+            clearNode(other);
+            this.renderActionButtons(target, {
+                includeReject: !this._isCollapsed
+            });
+        }
+    }
+    updateExpandedPresentation() {
+        this.domNode.classList.toggle("chat-plan-review-expanded", this._isExpanded && !this._isCollapsed);
+        this._restoreButton.label = this._isExpanded ? `$(${Codicon.screenNormal.id})` : `$(${Codicon.screenFull.id})`;
+        const tooltip = this._isExpanded ? ( localize(6865, "Restore Size")) : ( localize(6866, "Expand"));
+        this._restoreButton.element.setAttribute("aria-label", tooltip);
+        this._restoreButton.setTitle(tooltip);
+        this._messageScrollable.scanDomNode();
+    }
+    async openPlanFile() {
+        if (!this.review.planUri) {
+            return;
+        }
+        const uri = URI.revive(this.review.planUri);
+        await this._editorService.openEditor({
+            resource: uri
+        });
+    }
+    async submitApproval(action) {
+        if (this._isSubmitted) {
+            return;
+        }
+        if (action.permissionLevel === "autopilot") {
+            const confirmed = await this.confirmAutopilot();
+            if (!confirmed) {
+                return;
+            }
+        }
+        this._isSubmitted = true;
+        this._options.onSubmit({
+            action: action.label,
+            rejected: false
+        });
+        this.markUsed();
+    }
+    submitRejection() {
+        if (this._isSubmitted) {
+            return;
+        }
+        this._isSubmitted = true;
+        this._options.onSubmit({
+            rejected: true
+        });
+        this.markUsed();
+    }
+    enterFeedbackMode() {
+        this._isFeedbackMode = true;
+        if (this._feedbackSection) {
+            show(this._feedbackSection);
+        }
+        this.renderActionButtons(this._footerButtonsEl, {
+            includeReject: true
+        });
+        this._feedbackTextarea?.focus();
+        this._onDidChangeHeight.fire();
+    }
+    submitFeedback() {
+        if (this._isSubmitted) {
+            return;
+        }
+        const feedback = this._feedbackTextarea?.value.trim();
+        if (!feedback) {
+            return;
+        }
+        this._isSubmitted = true;
+        this._options.onSubmit({
+            rejected: false,
+            feedback
+        });
+        this.markUsed();
+    }
+    async confirmAutopilot() {
+        const result = await this._dialogService.prompt({
+            type: Severity.Warning,
+            message: ( localize(6867, "Enable Autopilot?")),
+            buttons: [{
+                label: ( localize(6868, "Enable")),
+                run: () => true
+            }, {
+                label: ( localize(6869, "Cancel")),
+                run: () => false
+            }],
+            custom: {
+                icon: Codicon.rocket,
+                markdownDetails: [{
+                    markdown: ( new MarkdownString(( localize(
+                        6870,
+                        "Autopilot will auto-approve all tool calls and continue working autonomously until the task is complete. This includes terminal commands, file edits, and external tool calls. The agent will make decisions on your behalf without asking for confirmation.\n\nYou can stop the agent at any time by clicking the stop button. This applies to the current session only."
+                    ))))
+                }]
+            }
+        });
+        return result.result === true;
+    }
+    markUsed() {
+        this.domNode.classList.add("chat-plan-review-used");
+        this._buttonStore.clear();
+        if (this._feedbackTextarea) {
+            this._feedbackTextarea.disabled = true;
+        }
+    }
+};
+ChatPlanReviewPart = ( __decorate([( __param(3, IMarkdownRendererService)), ( __param(4, IContextMenuService)), ( __param(5, IDialogService)), ( __param(6, IEditorService)), ( __param(7, IHoverService))], ChatPlanReviewPart));
+
+export { ChatPlanReviewPart };

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

@@ -1,10 +1,10 @@
-import { MarkdownString, type IMarkdownString } from "@codingame/monaco-vscode-api/vscode/vs/base/common/htmlContent";
+import { type IMarkdownString } from "@codingame/monaco-vscode-api/vscode/vs/base/common/htmlContent";
 import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
 import { ThemeIcon } from "@codingame/monaco-vscode-api/vscode/vs/base/common/themables";
 import { IMarkdownRenderer } from "@codingame/monaco-vscode-api/vscode/vs/platform/markdown/browser/markdownRenderer";
 import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
 import { IChatProgressMessage, IChatTask, IChatTaskSerialized, IChatToolInvocation, IChatToolInvocationSerialized } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService";
-import { IChatRendererContent } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/chatViewModel";
+import { IChatRendererContent, IChatWorkingProgress } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/chatViewModel";
 import { ChatTreeItem } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat";
 import { IChatContentPart, IChatContentPartRenderContext } from "./chatContentParts.js";
 import { IChatMarkdownAnchorService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/widget/chatContentParts/chatMarkdownAnchorService.service";
@@ -26,7 +26,7 @@ export declare class ChatProgressContentPart extends Disposable implements IChat
     constructor(progress: IChatProgressMessage | IChatTask | IChatTaskSerialized | {
         content: IMarkdownString;
     }, chatContentMarkdownRenderer: IMarkdownRenderer, context: IChatContentPartRenderContext, forceShowSpinner: boolean | undefined, forceShowMessage: boolean | undefined, icon: ThemeIcon | undefined, toolInvocation: IChatToolInvocation | IChatToolInvocationSerialized | undefined, shimmer: boolean | undefined, instantiationService: IInstantiationService, chatMarkdownAnchorService: IChatMarkdownAnchorService, configurationService: IConfigurationService);
-    updateMessage(content: MarkdownString): void;
+    updateMessage(content: IMarkdownString): void;
     hasSameContent(other: IChatRendererContent, followingContent: IChatRendererContent[], element: ChatTreeItem): boolean;
     private createApprovalMessage;
 }
@@ -34,9 +34,18 @@ export declare class ChatProgressSubPart extends Disposable {
     readonly domNode: HTMLElement;
     constructor(messageElement: HTMLElement, icon: ThemeIcon, tooltip: IMarkdownString | string | undefined, hoverService: IHoverService);
 }
-export declare class ChatWorkingProgressContentPart extends ChatProgressContentPart implements IChatContentPart {
-    constructor(_workingProgress: {
-        kind: "working";
-    }, chatContentMarkdownRenderer: IMarkdownRenderer, context: IChatContentPartRenderContext, instantiationService: IInstantiationService, chatMarkdownAnchorService: IChatMarkdownAnchorService, configurationService: IConfigurationService, languageModelToolsService: ILanguageModelToolsService);
+export declare class ChatWorkingProgressContentPart extends Disposable implements IChatContentPart {
+    readonly domNode: HTMLElement;
+    private readonly labelElement;
+    private readonly statsElement;
+    private explicitContent;
+    private readonly label;
+    private readonly hasState;
+    private readonly isCompleteState;
+    constructor(workingProgress: IChatWorkingProgress, chatContentMarkdownRenderer: IMarkdownRenderer, context: IChatContentPartRenderContext, instantiationService: IInstantiationService, chatMarkdownAnchorService: IChatMarkdownAnchorService, configurationService: IConfigurationService, languageModelToolsService: ILanguageModelToolsService);
+    private initializeWithState;
+    private renderCompletedProgress;
+    private startLiveProgress;
+    updateWorkingContent(content: IMarkdownString): void;
     hasSameContent(other: IChatRendererContent, followingContent: IChatRendererContent[], element: ChatTreeItem): boolean;
 }

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

@@ -16,11 +16,12 @@ import { getToolApprovalMessage } from './toolInvocationParts/chatToolPartUtilit
 import { IChatMarkdownAnchorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/widget/chatContentParts/chatMarkdownAnchorService.service';
 import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
 import { AccessibilityWorkbenchSettingId } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/accessibility/browser/accessibilityConfiguration';
+import { ChatConfiguration } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
 import { IHoverService } from '@codingame/monaco-vscode-api/vscode/vs/platform/hover/browser/hover.service';
 import { HoverStyle } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/hover/hover';
 import { ILanguageModelToolsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService.service';
 import { isEqual } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
-import { buildPhrasePool } from './chatThinkingContentPart.js';
+import { buildPhrasePool, defaultThinkingMessages } from './chatThinkingContentPart.js';
 
 let ChatProgressContentPart = class ChatProgressContentPart extends Disposable {
     constructor(
@@ -136,9 +137,9 @@ let ChatProgressSubPart = class ChatProgressSubPart extends Disposable {
     }
 };
 ChatProgressSubPart = ( __decorate([( __param(3, IHoverService))], ChatProgressSubPart));
-let ChatWorkingProgressContentPart = class ChatWorkingProgressContentPart extends ChatProgressContentPart {
+let ChatWorkingProgressContentPart = class ChatWorkingProgressContentPart extends Disposable {
     constructor(
-        _workingProgress,
+        workingProgress,
         chatContentMarkdownRenderer,
         context,
         instantiationService,
@@ -146,34 +147,76 @@ let ChatWorkingProgressContentPart = class ChatWorkingProgressContentPart extend
         configurationService,
         languageModelToolsService
     ) {
-        const defaultLabel = ( localize(6769, "Working"));
-        const pool = buildPhrasePool([defaultLabel], configurationService);
-        const label = pool[Math.floor(Math.random() * pool.length)];
-        const progressMessage = {
-            kind: "progressMessage",
-            content: ( new MarkdownString()).appendText(label)
-        };
-        super(
-            progressMessage,
-            chatContentMarkdownRenderer,
-            context,
-            undefined,
-            undefined,
-            undefined,
-            undefined,
-            true,
-            instantiationService,
-            chatMarkdownAnchorService,
-            configurationService
-        );
+        super();
+        this.explicitContent = workingProgress.content;
+        const persistentProgressEnabled = configurationService.getValue(ChatConfiguration.ChatPersistentProgressEnabled) !== false;
+        if (persistentProgressEnabled) {
+            const pool = buildPhrasePool(defaultThinkingMessages, configurationService);
+            this.label = pool[Math.floor(Math.random() * pool.length)];
+        } else {
+            this.label = ( localize(6871, "Working"));
+        }
+        this.domNode = $(".progress-container");
+        const iconElement = $("div");
+        const state = workingProgress.state;
+        this.hasState = !!state;
+        const isComplete = state?.isComplete ?? false;
+        this.isCompleteState = isComplete;
+        if (isComplete) {
+            iconElement.classList.add(...ThemeIcon.asClassNameArray(Codicon.check));
+        } else {
+            iconElement.classList.add(...ThemeIcon.asClassNameArray(ThemeIcon.modify(Codicon.loading, "spin")));
+        }
+        append(this.domNode, iconElement);
+        const messageContainer = $("div.rendered-markdown.progress-step.chat-working-progress-step");
+        this.labelElement = $("p");
+        this.statsElement = $("span");
+        append(messageContainer, this.labelElement);
+        append(messageContainer, this.statsElement);
+        append(this.domNode, messageContainer);
+        if (!isComplete) {
+            this.domNode.classList.add("shimmer-progress");
+        }
+        if (state) {
+            this.initializeWithState(state);
+        } else {
+            this.labelElement.textContent = this.explicitContent ? renderAsPlaintext(this.explicitContent) : this.label;
+        }
         this._register(languageModelToolsService.onDidPrepareToolCallBecomeUnresponsive(e => {
             if (isEqual(context.element.sessionResource, e.sessionResource)) {
-                this.updateMessage(( new MarkdownString(( localize(6770, "Waiting for tool '{0}' to respond...", e.toolData.displayName)))));
+                this.updateWorkingContent(( new MarkdownString(( localize(6872, "Waiting for tool '{0}' to respond...", e.toolData.displayName)))));
             }
         }));
     }
+    initializeWithState(state) {
+        if (state.isComplete) {
+            this.renderCompletedProgress(state);
+        } else {
+            this.startLiveProgress(state);
+        }
+    }
+    renderCompletedProgress(state) {}
+    startLiveProgress(state) {
+        if (!this.explicitContent) {
+            this.labelElement.textContent = this.label;
+        }
+    }
+    updateWorkingContent(content) {
+        this.explicitContent = content;
+        this.labelElement.textContent = renderAsPlaintext(content);
+        this.statsElement.textContent = "";
+    }
     hasSameContent(other, followingContent, element) {
-        return other.kind === "working";
+        if (other.kind !== "working") {
+            return false;
+        }
+        if (!!other.state !== this.hasState) {
+            return false;
+        }
+        if ((other.state?.isComplete ?? false) !== this.isCompleteState) {
+            return false;
+        }
+        return other.content?.value === this.explicitContent?.value;
     }
 };
 ChatWorkingProgressContentPart = ( __decorate([( __param(3, IInstantiationService)), ( __param(4, IChatMarkdownAnchorService)), ( __param(5, IConfigurationService)), ( __param(6, ILanguageModelToolsService))], ChatWorkingProgressContentPart));

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

@@ -9,6 +9,7 @@ import { ChatTreeItem } from "@codingame/monaco-vscode-api/vscode/vs/workbench/c
 import { IHoverService } from "@codingame/monaco-vscode-api/vscode/vs/platform/hover/browser/hover.service";
 import { IContextKeyService } from "@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service";
 import { IKeybindingService } from "@codingame/monaco-vscode-api/vscode/vs/platform/keybinding/common/keybinding.service";
+import { ICommandService } from "@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands.service";
 export interface IChatQuestionCarouselOptions {
     onSubmit: (answers: Map<string, IChatQuestionAnswerValue> | undefined) => void;
     shouldAutoFocus?: boolean;
@@ -21,6 +22,7 @@ export declare class ChatQuestionCarouselPart extends Disposable implements ICha
     private readonly _accessibilityService;
     private readonly _contextKeyService;
     private readonly _keybindingService;
+    private readonly _commandService;
     readonly domNode: HTMLElement;
     private readonly _onDidChangeHeight;
     readonly onDidChangeHeight: Event<void>;
@@ -54,13 +56,15 @@ export declare class ChatQuestionCarouselPart extends Disposable implements ICha
     private readonly _inChatQuestionCarouselContextKey;
     private _validationMessageElement;
     private _currentValidationError;
-    constructor(carousel: IChatQuestionCarousel, context: IChatContentPartRenderContext, _options: IChatQuestionCarouselOptions, _markdownRendererService: IMarkdownRendererService, _hoverService: IHoverService, _accessibilityService: IAccessibilityService, _contextKeyService: IContextKeyService, _keybindingService: IKeybindingService);
+    private _focusTerminalButtonContainer;
+    constructor(carousel: IChatQuestionCarousel, context: IChatContentPartRenderContext, _options: IChatQuestionCarouselOptions, _markdownRendererService: IMarkdownRendererService, _hoverService: IHoverService, _accessibilityService: IAccessibilityService, _contextKeyService: IContextKeyService, _keybindingService: IKeybindingService, _commandService: ICommandService);
     /**
      * Saves the current question's answer to the answers map.
      */
     private saveCurrentAnswer;
     private persistDraftState;
     private toggleCollapsed;
+    private _focusTerminal;
     private updateCollapsedPresentation;
     /**
      * Navigates the carousel by the given delta.