@codingame/monaco-vscode-api 37.2.0 → 37.3.1

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

@@ -0,0 +1,125 @@
+
+import { __decorate, __param } from '../../../../../../../../../../external/tslib/tslib.es6.js';
+import { $, append } from '../../../../../../../base/browser/dom.js';
+import { renderMarkdown } from '../../../../../../../base/browser/markdownRenderer.js';
+import { decodeBase64 } from '../../../../../../../base/common/buffer.js';
+import { CancellationTokenSource } from '../../../../../../../base/common/cancellation.js';
+import { Codicon } from '../../../../../../../base/common/codicons.js';
+import { isCancellationError } from '../../../../../../../base/common/errors.js';
+import { ThemeIcon } from '../../../../../../../base/common/themables.js';
+import { localize } from '../../../../../../../nls.js';
+import { IInstantiationService } from '../../../../../../../platform/instantiation/common/instantiation.js';
+import { IChatToolInvocation } from '../../../../common/chatService/chatService.js';
+import { IChatOutputRendererService } from '../../../chatOutputItemRenderer.service.js';
+import { ChatProgressSubPart } from '../chatProgressContentPart.js';
+import { IChatOutputPartStateCache } from '../chatOutputPartStateCache.service.js';
+import { BaseChatToolInvocationSubPart } from './chatToolInvocationSubPart.js';
+
+let ChatToolOutputSubPart = class ChatToolOutputSubPart extends BaseChatToolInvocationSubPart {
+    constructor(
+        toolInvocation,
+        context,
+        onDidRemount,
+        chatOutputItemRendererService,
+        instantiationService,
+        stateCache
+    ) {
+        super(toolInvocation);
+        this.context = context;
+        this.onDidRemount = onDidRemount;
+        this.chatOutputItemRendererService = chatOutputItemRendererService;
+        this.instantiationService = instantiationService;
+        this.stateCache = stateCache;
+        this.codeblocks = [];
+        this._disposeCts = this._register(( new CancellationTokenSource()));
+        const details = toolInvocation.kind === "toolInvocation" ? IChatToolInvocation.resultDetails(toolInvocation) : {
+            output: {
+                type: "data",
+                mimeType: toolInvocation.resultDetails.output.mimeType,
+                value: decodeBase64(toolInvocation.resultDetails.output.base64Data)
+            }
+        };
+        this.domNode = $("div.tool-output-part");
+        if (toolInvocation.invocationMessage) {
+            const titleEl = $(".output-title");
+            this.domNode.appendChild(titleEl);
+            if (typeof toolInvocation.invocationMessage === "string") {
+                titleEl.textContent = toolInvocation.invocationMessage;
+            } else {
+                const md = this._register(renderMarkdown(toolInvocation.invocationMessage));
+                titleEl.appendChild(md.element);
+            }
+        }
+        this.domNode.appendChild(this.createOutputPart(toolInvocation, details));
+    }
+    dispose() {
+        this._disposeCts.dispose(true);
+        super.dispose();
+    }
+    createOutputPart(toolInvocation, details) {
+        const parent = $("div.webview-output");
+        parent.style.maxHeight = "80vh";
+        const partState = this.stateCache.get(toolInvocation.toolCallId) ?? {
+            height: 0
+        };
+        this.stateCache.set(toolInvocation.toolCallId, partState);
+        if (partState.height) {
+            parent.style.height = `${partState.height}px`;
+        }
+        const progressMessage = $("span");
+        progressMessage.textContent = ( localize(11789, "Rendering tool output..."));
+        const progressPart = this._register(this.instantiationService.createInstance(
+            ChatProgressSubPart,
+            progressMessage,
+            ThemeIcon.modify(Codicon.loading, "spin"),
+            undefined
+        ));
+        parent.appendChild(progressPart.domNode);
+        this.chatOutputItemRendererService.renderOutputPart(details.output.mimeType, details.output.value.buffer, parent, {
+            webviewState: partState.webviewState,
+            chatSessionResource: this.context.element.sessionResource
+        }, this._disposeCts.token).then(renderedItem => {
+            if (this._disposeCts.token.isCancellationRequested) {
+                return;
+            }
+            this._register(renderedItem);
+            progressPart.domNode.remove();
+            this._register(renderedItem.webview.onDidUpdateState(e => {
+                partState.webviewState = e;
+            }));
+            this._register(renderedItem.onDidChangeHeight(newHeight => {
+                partState.height = newHeight;
+            }));
+            this._register(this.context.onDidChangeVisibility(visible => {
+                if (visible) {
+                    renderedItem.reinitialize();
+                }
+            }));
+            this._register(this.onDidRemount(() => {
+                renderedItem.reinitialize();
+            }));
+        }, error => {
+            if (isCancellationError(error)) {
+                return;
+            }
+            console.error("Error rendering tool output:", error);
+            const errorNode = $(".output-error");
+            const errorHeaderNode = $(".output-error-header");
+            append(errorNode, errorHeaderNode);
+            const iconElement = $("div");
+            iconElement.classList.add(...ThemeIcon.asClassNameArray(Codicon.error));
+            errorHeaderNode.append(iconElement);
+            const errorTitleNode = $(".output-error-title");
+            errorTitleNode.textContent = ( localize(11790, "Error rendering the tool output"));
+            errorHeaderNode.append(errorTitleNode);
+            const errorMessageNode = $(".output-error-details");
+            errorMessageNode.textContent = error?.message || String(error);
+            errorNode.append(errorMessageNode);
+            progressPart.domNode.replaceWith(errorNode);
+        });
+        return parent;
+    }
+};
+ChatToolOutputSubPart = ( __decorate([( __param(3, IChatOutputRendererService)), ( __param(4, IInstantiationService)), ( __param(5, IChatOutputPartStateCache))], ChatToolOutputSubPart));
+
+export { ChatToolOutputSubPart };

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

@@ -0,0 +1,20 @@
+import { IMarkdownString } from "../../../../../../../base/common/htmlContent.js";
+import { ConfirmedReason, IChatToolInvocation, IChatToolInvocationSerialized } from "../../../../common/chatService/chatService.js";
+export declare function isMcpToolInvocation(toolInvocation: IChatToolInvocation | IChatToolInvocationSerialized): boolean;
+export declare function isAskQuestionsToolInvocation(toolInvocation: IChatToolInvocation | IChatToolInvocationSerialized): boolean;
+/**
+ * Determines whether a tool invocation's progress text should shimmer.
+ */
+export declare function shouldShimmerForTool(toolInvocation: IChatToolInvocation | IChatToolInvocationSerialized, content: string | IMarkdownString | undefined): boolean;
+/**
+ * Creates a markdown message explaining why a tool was auto-approved.
+ * @param toolInvocation The tool invocation to get the approval message for
+ * @returns A markdown string with the approval message, or undefined if no message should be shown
+ */
+export declare function getToolApprovalMessage(toolInvocation: IChatToolInvocation | IChatToolInvocationSerialized): IMarkdownString | undefined;
+/**
+ * Creates a markdown message from a ConfirmedReason explaining why a tool was auto-approved.
+ * @param reason The confirmation reason
+ * @returns A markdown string with the approval message, or undefined if no message should be shown
+ */
+export declare function getApprovalMessageFromReason(reason: ConfirmedReason): IMarkdownString | undefined;

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

@@ -0,0 +1,65 @@
+
+import { MarkdownString, createMarkdownCommandLink } from '../../../../../../../base/common/htmlContent.js';
+import { localize } from '../../../../../../../nls.js';
+import { IChatToolInvocation, ToolConfirmKind } from '../../../../common/chatService/chatService.js';
+
+function isMcpToolInvocation(toolInvocation) {
+    return toolInvocation.source?.type === "mcp" || toolInvocation.toolId.toLowerCase().includes("mcp");
+}
+function isAskQuestionsToolInvocation(toolInvocation) {
+    return toolInvocation.toolId === "copilot_askQuestions" || toolInvocation.toolId === "vscode_askQuestions" || toolInvocation.toolId === "ask_user" || toolInvocation.toolId === "AskUserQuestion" || toolInvocation.toolId === "request_user_input";
+}
+function shouldShimmerForTool(toolInvocation, content) {
+    if (!isAskQuestionsToolInvocation(toolInvocation) || IChatToolInvocation.isComplete(toolInvocation)) {
+        return false;
+    }
+    return getMarkdownValue(content) === getMarkdownValue(toolInvocation.invocationMessage);
+}
+function getMarkdownValue(content) {
+    return (typeof content === "string" ? content : content?.value)?.replaceAll(" ", " ").replace(/\\[\\`*_{}\[\]()#+\-!~]/g, escaped => escaped.slice(1));
+}
+function getToolApprovalMessage(toolInvocation) {
+    const reason = IChatToolInvocation.executionConfirmedOrDenied(toolInvocation);
+    if (!reason || typeof reason === "boolean") {
+        return undefined;
+    }
+    return getApprovalMessageFromReason(reason);
+}
+function getApprovalMessageFromReason(reason) {
+    let md;
+    switch (reason.type) {
+    case ToolConfirmKind.Setting:
+        md = ( localize(11791, "Auto approved by {0}", createMarkdownCommandLink({
+            text: "`" + reason.id + "`",
+            id: "workbench.action.openSettings",
+            arguments: [reason.id],
+            tooltip: ( localize(11792, "Open settings"))
+        }, false)));
+        break;
+    case ToolConfirmKind.LmServicePerTool:
+        md = reason.scope === "session" ? ( localize(11793, "Auto approved for this session")) : reason.scope === "workspace" ? ( localize(11794, "Auto approved for this workspace")) : ( localize(11795, "Auto approved for this profile"));
+        md += " (" + createMarkdownCommandLink({
+            text: ( localize(11796, "Edit")),
+            id: "workbench.action.chat.editToolApproval",
+            arguments: [reason.scope],
+            tooltip: ( localize(11797, "Edit tool approval settings"))
+        }) + ")";
+        break;
+    case ToolConfirmKind.ConfirmationNotNeeded:
+        if (reason.reason) {
+            return typeof reason.reason === "string" ? ( new MarkdownString(reason.reason, {
+                isTrusted: true
+            })) : reason.reason;
+        }
+        return undefined;
+    case ToolConfirmKind.UserAction:
+    case ToolConfirmKind.Denied:
+    default:
+        return undefined;
+    }
+    return ( new MarkdownString(md, {
+        isTrusted: true
+    }));
+}
+
+export { getApprovalMessageFromReason, getToolApprovalMessage, isAskQuestionsToolInvocation, isMcpToolInvocation, shouldShimmerForTool };

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

@@ -0,0 +1,24 @@
+import { IMarkdownRenderer } from "../../../../../../../platform/markdown/browser/markdownRenderer.js";
+import { IConfigurationService } from "../../../../../../../platform/configuration/common/configuration.service.js";
+import { IInstantiationService } from "../../../../../../../platform/instantiation/common/instantiation.js";
+import { IChatToolInvocation, IChatToolInvocationSerialized } from "../../../../common/chatService/chatService.js";
+import { IChatCodeBlockInfo } from "../../../chat.js";
+import { IChatContentPartRenderContext } from "../chatContentParts.js";
+import { BaseChatToolInvocationSubPart } from "./chatToolInvocationSubPart.js";
+export declare class ChatToolProgressSubPart extends BaseChatToolInvocationSubPart {
+    private readonly context;
+    private readonly renderer;
+    private readonly announcedToolProgressKeys;
+    private readonly instantiationService;
+    private readonly configurationService;
+    readonly domNode: HTMLElement;
+    readonly codeblocks: IChatCodeBlockInfo[];
+    constructor(toolInvocation: IChatToolInvocation | IChatToolInvocationSerialized, context: IChatContentPartRenderContext, renderer: IMarkdownRenderer, announcedToolProgressKeys: Set<string> | undefined, instantiationService: IInstantiationService, configurationService: IConfigurationService);
+    private createProgressPart;
+    private get toolIsConfirmed();
+    private renderProgressContent;
+    private getAnnouncementKey;
+    private computeShouldAnnounce;
+    private provideScreenReaderStatus;
+    private hasMeaningfulContent;
+}

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

@@ -0,0 +1,137 @@
+
+import { __decorate, __param } from '../../../../../../../../../../external/tslib/tslib.es6.js';
+import { createElement, clearNode, reset } from '../../../../../../../base/browser/dom.js';
+import { renderAsPlaintext } from '../../../../../../../base/browser/markdownRenderer.js';
+import { status } from '../../../../../../../base/browser/ui/aria/aria.js';
+import { MarkdownString } from '../../../../../../../base/common/htmlContent.js';
+import { stripIcons } from '../../../../../../../base/common/iconLabels.js';
+import '../../../../../../../base/common/observableInternal/index.js';
+import { IConfigurationService } from '../../../../../../../platform/configuration/common/configuration.service.js';
+import { IInstantiationService } from '../../../../../../../platform/instantiation/common/instantiation.js';
+import { IChatToolInvocation, ToolConfirmKind } from '../../../../common/chatService/chatService.js';
+import { AccessibilityWorkbenchSettingId } from '../../../../../accessibility/browser/accessibilityConfiguration.js';
+import { ChatProgressContentPart } from '../chatProgressContentPart.js';
+import { BaseChatToolInvocationSubPart } from './chatToolInvocationSubPart.js';
+import { shouldShimmerForTool } from './chatToolPartUtilities.js';
+import { autorun } from '../../../../../../../base/common/observableInternal/reactions/autorun.js';
+
+let ChatToolProgressSubPart = class ChatToolProgressSubPart extends BaseChatToolInvocationSubPart {
+    constructor(
+        toolInvocation,
+        context,
+        renderer,
+        announcedToolProgressKeys,
+        instantiationService,
+        configurationService
+    ) {
+        super(toolInvocation);
+        this.context = context;
+        this.renderer = renderer;
+        this.announcedToolProgressKeys = announcedToolProgressKeys;
+        this.instantiationService = instantiationService;
+        this.configurationService = configurationService;
+        this.codeblocks = [];
+        this.domNode = this.createProgressPart();
+    }
+    createProgressPart() {
+        const isComplete = IChatToolInvocation.isComplete(this.toolInvocation);
+        if (isComplete && this.toolIsConfirmed && (this.toolInvocation.pastTenseMessage || this.toolInvocation.invocationMessage)) {
+            const key = this.getAnnouncementKey("complete");
+            const completionContent = this.toolInvocation.pastTenseMessage ?? this.toolInvocation.invocationMessage;
+            if (!this.hasMeaningfulContent(completionContent)) {
+                return createElement("div");
+            }
+            const shouldAnnounce = this.toolInvocation.kind === "toolInvocation" && this.hasMeaningfulContent(completionContent) ? this.computeShouldAnnounce(key) : false;
+            const part = this.renderProgressContent(completionContent, shouldAnnounce);
+            this._register(part);
+            return part.domNode;
+        } else {
+            const container = createElement("div");
+            this._register(autorun(reader => {
+                let progressContent;
+                const key = this.getAnnouncementKey("progress");
+                if (this.toolInvocation.kind === "toolInvocation") {
+                    const state = this.toolInvocation.state.read(reader);
+                    if (state.type === IChatToolInvocation.StateKind.Cancelled && state.reasonMessage) {
+                        progressContent = state.reasonMessage;
+                    } else if (state.type === IChatToolInvocation.StateKind.Executing) {
+                        const progressMessage = state.progress.read(reader)?.message;
+                        progressContent = this.hasMeaningfulContent(progressMessage) ? progressMessage : this.toolInvocation.invocationMessage;
+                    } else {
+                        progressContent = this.toolInvocation.invocationMessage;
+                    }
+                } else {
+                    progressContent = this.toolInvocation.invocationMessage;
+                }
+                if (!this.hasMeaningfulContent(progressContent)) {
+                    clearNode(container);
+                    return;
+                }
+                const shouldAnnounce = this.toolInvocation.kind === "toolInvocation" && this.hasMeaningfulContent(progressContent) ? this.computeShouldAnnounce(key) : false;
+                const part = reader.store.add(this.renderProgressContent(progressContent, shouldAnnounce));
+                reset(container, part.domNode);
+            }));
+            return container;
+        }
+    }
+    get toolIsConfirmed() {
+        const c = IChatToolInvocation.executionConfirmedOrDenied(this.toolInvocation);
+        return !!c && c.type !== ToolConfirmKind.Denied;
+    }
+    renderProgressContent(content, shouldAnnounce) {
+        if (typeof content === "string") {
+            content = ( new MarkdownString()).appendText(content);
+        }
+        const progressMessage = {
+            kind: "progressMessage",
+            content
+        };
+        if (shouldAnnounce) {
+            this.provideScreenReaderStatus(content);
+        }
+        const shouldShimmer = shouldShimmerForTool(this.toolInvocation, content);
+        return this.instantiationService.createInstance(
+            ChatProgressContentPart,
+            progressMessage,
+            this.renderer,
+            this.context,
+            shouldShimmer ? true : undefined,
+            true,
+            this.getProgressIcon(),
+            this.toolInvocation,
+            shouldShimmer
+        );
+    }
+    getAnnouncementKey(kind) {
+        return `${kind}:${this.toolInvocation.toolCallId}`;
+    }
+    computeShouldAnnounce(key) {
+        if (!this.announcedToolProgressKeys) {
+            return false;
+        }
+        if (!this.configurationService.getValue(AccessibilityWorkbenchSettingId.VerboseChatProgressUpdates)) {
+            return false;
+        }
+        if (( this.announcedToolProgressKeys.has(key))) {
+            return false;
+        }
+        this.announcedToolProgressKeys.add(key);
+        return true;
+    }
+    provideScreenReaderStatus(content) {
+        const message = typeof content === "string" ? content : stripIcons(renderAsPlaintext(content, {
+            useLinkFormatter: true
+        }));
+        status(message);
+    }
+    hasMeaningfulContent(content) {
+        if (!content) {
+            return false;
+        }
+        const text = typeof content === "string" ? content : content.value;
+        return text.trim().length > 0;
+    }
+};
+ChatToolProgressSubPart = ( __decorate([( __param(4, IInstantiationService)), ( __param(5, IConfigurationService))], ChatToolProgressSubPart));
+
+export { ChatToolProgressSubPart };

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

@@ -0,0 +1,19 @@
+import { IMarkdownRenderer } from "../../../../../../../platform/markdown/browser/markdownRenderer.js";
+import { IInstantiationService } from "../../../../../../../platform/instantiation/common/instantiation.js";
+import { IChatToolInvocation } from "../../../../common/chatService/chatService.js";
+import { IChatCodeBlockInfo } from "../../../chat.js";
+import { IChatContentPartRenderContext } from "../chatContentParts.js";
+import { BaseChatToolInvocationSubPart } from "./chatToolInvocationSubPart.js";
+/**
+ * Sub-part for rendering a tool invocation in the streaming state.
+ * This shows progress while the tool arguments are being streamed from the LM.
+ */
+export declare class ChatToolStreamingSubPart extends BaseChatToolInvocationSubPart {
+    private readonly context;
+    private readonly renderer;
+    private readonly instantiationService;
+    readonly domNode: HTMLElement;
+    readonly codeblocks: IChatCodeBlockInfo[];
+    constructor(toolInvocation: IChatToolInvocation, context: IChatContentPartRenderContext, renderer: IMarkdownRenderer, instantiationService: IInstantiationService);
+    private createStreamingPart;
+}

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

@@ -0,0 +1,69 @@
+
+import { __decorate, __param } from '../../../../../../../../../../external/tslib/tslib.es6.js';
+import { createElement, clearNode, reset } from '../../../../../../../base/browser/dom.js';
+import { MarkdownString } from '../../../../../../../base/common/htmlContent.js';
+import '../../../../../../../base/common/observableInternal/index.js';
+import { IInstantiationService } from '../../../../../../../platform/instantiation/common/instantiation.js';
+import { IChatToolInvocation } from '../../../../common/chatService/chatService.js';
+import { ChatProgressContentPart } from '../chatProgressContentPart.js';
+import { BaseChatToolInvocationSubPart } from './chatToolInvocationSubPart.js';
+import { autorun } from '../../../../../../../base/common/observableInternal/reactions/autorun.js';
+
+let ChatToolStreamingSubPart = class ChatToolStreamingSubPart extends BaseChatToolInvocationSubPart {
+    constructor(toolInvocation, context, renderer, instantiationService) {
+        super(toolInvocation);
+        this.context = context;
+        this.renderer = renderer;
+        this.instantiationService = instantiationService;
+        this.codeblocks = [];
+        this.domNode = this.createStreamingPart();
+    }
+    createStreamingPart() {
+        const container = createElement("div");
+        if (this.toolInvocation.kind !== "toolInvocation") {
+            return container;
+        }
+        const toolInvocation = this.toolInvocation;
+        const state = toolInvocation.state.get();
+        if (state.type !== IChatToolInvocation.StateKind.Streaming) {
+            return container;
+        }
+        this._register(autorun(reader => {
+            const currentState = toolInvocation.state.read(reader);
+            if (currentState.type !== IChatToolInvocation.StateKind.Streaming) {
+                clearNode(container);
+                this._onNeedsRerender.fire();
+                return;
+            }
+            const streamingMessage = currentState.streamingMessage.read(reader);
+            const displayMessage = streamingMessage ?? toolInvocation.invocationMessage;
+            const messageText = typeof displayMessage === "string" ? displayMessage : displayMessage.value;
+            if (!messageText || messageText.trim().length === 0) {
+                clearNode(container);
+                return;
+            }
+            const content = typeof displayMessage === "string" ? ( new MarkdownString()).appendText(displayMessage) : displayMessage;
+            const progressMessage = {
+                kind: "progressMessage",
+                content
+            };
+            const shimmer = !toolInvocation.isAttachedToThinking;
+            const part = reader.store.add(this.instantiationService.createInstance(
+                ChatProgressContentPart,
+                progressMessage,
+                this.renderer,
+                this.context,
+                shimmer ? true : undefined,
+                true,
+                this.getProgressIcon(),
+                toolInvocation,
+                shimmer
+            ));
+            reset(container, part.domNode);
+        }));
+        return container;
+    }
+};
+ChatToolStreamingSubPart = ( __decorate([( __param(3, IInstantiationService))], ChatToolStreamingSubPart));
+
+export { ChatToolStreamingSubPart };

package/vscode/src/vs/workbench/contrib/chat/browser/widget/chatContentParts/toolInvocationParts/media/toolRiskBadge.css

@@ -0,0 +1,76 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+/* Risk subtitle: a slim row that sits below the main content (e.g. the
+ * terminal command box or elicitation message), above the action buttons.
+ * Renders an icon at the risk level's accent color followed by the
+ * LLM-generated explanation in the regular foreground color. */
+
+.chat-confirmation-widget2 > .tool-risk-badge {
+	display: flex;
+	align-items: center;
+	gap: 4px;
+	padding: 6px 8px;
+	line-height: 1.5;
+	color: var(--vscode-foreground);
+	border-top: 1px solid var(--vscode-chat-requestBorder);
+	background: transparent;
+	user-select: none;
+}
+
+.chat-confirmation-widget2 > .tool-risk-badge .tool-risk-icon {
+	flex: 0 0 auto;
+	display: inline-flex;
+	align-items: center;
+	justify-content: center;
+	min-width: 12px;
+	line-height: 1;
+	color: var(--tool-risk-accent, var(--vscode-descriptionForeground));
+}
+
+/* Outrank `.monaco-workbench .codicon[class*='codicon-']` so these compact
+ * badge icons are not promoted to the workbench's base codicon size. */
+.chat-confirmation-widget2 > .tool-risk-badge .tool-risk-icon.codicon,
+.chat-confirmation-widget2 > .tool-risk-badge .tool-risk-details-icon.codicon {
+	font-size: var(--vscode-codiconFontSize-compact);
+}
+
+.chat-confirmation-widget2 > .tool-risk-badge .tool-risk-text {
+	min-width: 0;
+	flex: 1 1 auto;
+	overflow-wrap: anywhere;
+}
+
+.chat-confirmation-widget2 > .tool-risk-badge .tool-risk-details-icon {
+	flex: 0 0 auto;
+	display: inline-flex;
+	align-items: center;
+	justify-content: center;
+	line-height: 1;
+	color: var(--vscode-descriptionForeground);
+	cursor: pointer;
+	border-radius: 3px;
+}
+
+.chat-confirmation-widget2 > .tool-risk-badge .tool-risk-details-icon:focus {
+	outline: 1px solid var(--vscode-focusBorder);
+	outline-offset: 1px;
+}
+
+.chat-confirmation-widget2 > .tool-risk-badge.loading {
+	opacity: 0.7;
+}
+
+.chat-confirmation-widget2 > .tool-risk-badge.green {
+	--tool-risk-accent: var(--vscode-charts-green, #388a34);
+}
+
+.chat-confirmation-widget2 > .tool-risk-badge.orange {
+	--tool-risk-accent: var(--vscode-editorWarning-foreground, #cca700);
+}
+
+.chat-confirmation-widget2 > .tool-risk-badge.red {
+	--tool-risk-accent: var(--vscode-editorError-foreground, #f14c4c);
+}

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

@@ -0,0 +1,60 @@
+import { Disposable } from "../../../../../../../base/common/lifecycle.js";
+import { Event } from "../../../../../../../base/common/event.js";
+/**
+ * The auto-expand algorithm for terminal tool progress parts.
+ *
+ * The algorithm is:
+ * 1. When command executes, kick off 500ms timeout - expand if there's real output (data events
+ *    may fire before onCommandExecuted due to shell integration sequences, so we can't rely on
+ *    receivedData to skip this path)
+ * 2. On first data event, wait 50ms and expand if command not yet finished and has real output
+ * 3. Fast commands (finishing quickly) should NOT auto-expand to prevent flickering
+ */
+export interface ITerminalToolAutoExpandOptions {
+    /**
+     * Event fired when a command starts executing.
+     */
+    readonly onCommandExecuted: Event<unknown>;
+    /**
+     * Event fired when a command finishes executing.
+     */
+    readonly onCommandFinished: Event<unknown>;
+    /**
+     * Event fired when data is received from the terminal.
+     */
+    readonly onWillData: Event<unknown>;
+    /**
+     * Check if the output should auto-expand (e.g. not already expanded, user hasn't toggled).
+     */
+    shouldAutoExpand(): boolean;
+    /**
+     * Check if there is real output (not just shell integration sequences).
+     */
+    hasRealOutput(): boolean;
+}
+/**
+ * Timeout constants for the auto-expand algorithm.
+ */
+export declare enum TerminalToolAutoExpandTimeout {
+    /**
+     * Timeout in milliseconds to wait when no data events are received before checking for auto-expand.
+     */
+    NoData = 500,
+    /**
+     * Timeout in milliseconds to wait after first data event before checking for auto-expand.
+     * This prevents flickering for fast commands like `ls` that finish quickly.
+     */
+    DataEvent = 50
+}
+export declare class TerminalToolAutoExpand extends Disposable {
+    private readonly _options;
+    private _commandFinished;
+    private _receivedData;
+    private readonly _dataEventTimeout;
+    private readonly _noDataTimeout;
+    private readonly _onDidRequestExpand;
+    readonly onDidRequestExpand: Event<void>;
+    constructor(_options: ITerminalToolAutoExpandOptions);
+    private _setupListeners;
+    private _clearAutoExpandTimeouts;
+}