@codingame/monaco-vscode-katex-common 25.1.2 → 26.0.1

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

@@ -3,8 +3,6 @@ import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib
 import { $ } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
 import { Separator } from '@codingame/monaco-vscode-api/vscode/vs/base/common/actions';
 import { getExtensionForMimeType } from '@codingame/monaco-vscode-api/vscode/vs/base/common/mime';
-import { ILanguageService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/languages/language.service';
-import { IModelService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/model.service';
 import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
 import { IContextKeyService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service';
 import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
@@ -23,41 +21,60 @@ let ChatToolPostExecuteConfirmationPart = class ChatToolPostExecuteConfirmationP
     get codeblocks() {
         return this._codeblocks;
     }
-    constructor(toolInvocation, context, instantiationService, keybindingService, modelService, languageService, contextKeyService, chatWidgetService, languageModelToolsService, confirmationService) {
-        super(toolInvocation, context, instantiationService, keybindingService, contextKeyService, chatWidgetService, languageModelToolsService);
-        this.modelService = modelService;
-        this.languageService = languageService;
+    constructor(
+        toolInvocation,
+        context,
+        instantiationService,
+        keybindingService,
+        contextKeyService,
+        chatWidgetService,
+        languageModelToolsService,
+        confirmationService
+    ) {
+        super(
+            toolInvocation,
+            context,
+            instantiationService,
+            keybindingService,
+            contextKeyService,
+            chatWidgetService,
+            languageModelToolsService
+        );
         this.confirmationService = confirmationService;
         this._codeblocks = [];
         const subtitle = toolInvocation.pastTenseMessage || toolInvocation.invocationMessage;
         this.render({
             allowActionId: AcceptToolPostConfirmationActionId,
             skipActionId: SkipToolPostConfirmationActionId,
-            allowLabel: ( localize(5760, "Allow")),
-            skipLabel: ( localize(5761, 'Skip Results')),
-            partType: 'chatToolPostConfirmation',
-            subtitle: typeof subtitle === 'string' ? subtitle : subtitle?.value,
+            allowLabel: ( localize(6016, "Allow")),
+            skipLabel: ( localize(6017, "Skip Results")),
+            partType: "chatToolPostConfirmation",
+            subtitle: typeof subtitle === "string" ? subtitle : subtitle?.value
         });
     }
     createContentElement() {
-        if (this.toolInvocation.kind !== 'toolInvocation') {
-            throw ( new Error('post-approval not supported for serialized data'));
+        if (this.toolInvocation.kind !== "toolInvocation") {
+            throw ( new Error("post-approval not supported for serialized data"));
         }
         const state = this.toolInvocation.state.get();
         if (state.type !== IChatToolInvocation.StateKind.WaitingForPostApproval) {
-            throw ( new Error('Tool invocation is not waiting for post-approval'));
+            throw ( new Error("Tool invocation is not waiting for post-approval"));
         }
         return this.createResultsDisplay(this.toolInvocation, state.contentForModel);
     }
     getTitle() {
-        return localize(5762, "Approve Tool Result");
+        return localize(6018, "Approve Tool Result");
     }
     additionalPrimaryActions() {
         const actions = super.additionalPrimaryActions();
+        const state = this.toolInvocation.state.get();
+        if (state.type !== IChatToolInvocation.StateKind.WaitingForPostApproval) {
+            return actions;
+        }
         const confirmActions = this.confirmationService.getPostConfirmActions({
             toolId: this.toolInvocation.toolId,
             source: this.toolInvocation.source,
-            parameters: this.toolInvocation.parameters
+            parameters: state.parameters
         });
         for (const action of confirmActions) {
             if (action.divider) {
@@ -69,7 +86,9 @@ let ChatToolPostExecuteConfirmationPart = class ChatToolPostExecuteConfirmationP
                 data: async () => {
                     const shouldConfirm = await action.select();
                     if (shouldConfirm) {
-                        this.confirmWith(this.toolInvocation, { type: ToolConfirmKind.UserAction });
+                        this.confirmWith(this.toolInvocation, {
+                            type: ToolConfirmKind.UserAction
+                        });
                     }
                 }
             });
@@ -77,124 +96,109 @@ let ChatToolPostExecuteConfirmationPart = class ChatToolPostExecuteConfirmationP
         return actions;
     }
     createResultsDisplay(toolInvocation, contentForModel) {
-        const container = $('.tool-postconfirm-display');
+        const container = $(".tool-postconfirm-display");
         if (!contentForModel || contentForModel.length === 0) {
-            container.textContent = ( localize(5763, 'No results to display'));
+            container.textContent = ( localize(6019, "No results to display"));
             return container;
         }
         const parts = [];
         for (const [i, part] of contentForModel.entries()) {
-            if (part.kind === 'text') {
-                const model = this._register(this.modelService.createModel(part.value, this.languageService.createById('plaintext'), undefined, true));
+            if (part.kind === "text") {
                 parts.push({
-                    kind: 'code',
+                    kind: "code",
                     title: part.title,
-                    textModel: model,
-                    languageId: model.getLanguageId(),
+                    data: part.value,
+                    languageId: "plaintext",
+                    codeBlockIndex: i,
+                    ownerMarkdownPartId: this.codeblocksPartId,
                     options: {
                         hideToolbar: true,
                         reserveWidth: 19,
                         maxHeightInLines: 13,
                         verticalPadding: 5,
-                        editorOptions: { wordWrap: 'on', readOnly: true }
-                    },
-                    codeBlockInfo: {
-                        codeBlockIndex: i,
-                        codemapperUri: undefined,
-                        elementId: this.context.element.id,
-                        focus: () => { },
-                        ownerMarkdownPartId: this.codeblocksPartId,
-                        uri: model.uri,
-                        chatSessionResource: this.context.element.sessionResource,
-                        uriPromise: Promise.resolve(model.uri)
+                        editorOptions: {
+                            wordWrap: "on",
+                            readOnly: true
+                        }
                     }
                 });
-            }
-            else if (part.kind === 'promptTsx') {
+            } else if (part.kind === "promptTsx") {
                 const stringified = stringifyPromptTsxPart(part);
-                const model = this._register(this.modelService.createModel(stringified, this.languageService.createById('json'), undefined, true));
                 parts.push({
-                    kind: 'code',
-                    textModel: model,
-                    languageId: model.getLanguageId(),
+                    kind: "code",
+                    data: stringified,
+                    languageId: "json",
+                    codeBlockIndex: i,
+                    ownerMarkdownPartId: this.codeblocksPartId,
                     options: {
                         hideToolbar: true,
                         reserveWidth: 19,
                         maxHeightInLines: 13,
                         verticalPadding: 5,
-                        editorOptions: { wordWrap: 'on', readOnly: true }
-                    },
-                    codeBlockInfo: {
-                        codeBlockIndex: i,
-                        codemapperUri: undefined,
-                        elementId: this.context.element.id,
-                        focus: () => { },
-                        ownerMarkdownPartId: this.codeblocksPartId,
-                        uri: model.uri,
-                        chatSessionResource: this.context.element.sessionResource,
-                        uriPromise: Promise.resolve(model.uri)
+                        editorOptions: {
+                            wordWrap: "on",
+                            readOnly: true
+                        }
                     }
                 });
-            }
-            else if (part.kind === 'data') {
+            } else if (part.kind === "data") {
                 const mimeType = part.value.mimeType;
                 const data = part.value.data;
-                if (mimeType?.startsWith('image/')) {
-                    const permalinkBasename = getExtensionForMimeType(mimeType) ? `image${getExtensionForMimeType(mimeType)}` : 'image.bin';
-                    const permalinkUri = ChatResponseResource.createUri(this.context.element.sessionResource, toolInvocation.toolCallId, i, permalinkBasename);
-                    parts.push({ kind: 'data', value: data.buffer, mimeType, uri: permalinkUri, audience: part.audience });
-                }
-                else {
-                    const decoder = ( new TextDecoder('utf-8', { fatal: true }));
+                if (mimeType?.startsWith("image/")) {
+                    const permalinkBasename = getExtensionForMimeType(mimeType) ? `image${getExtensionForMimeType(mimeType)}` : "image.bin";
+                    const permalinkUri = ChatResponseResource.createUri(
+                        this.context.element.sessionResource,
+                        toolInvocation.toolCallId,
+                        i,
+                        permalinkBasename
+                    );
+                    parts.push({
+                        kind: "data",
+                        value: data.buffer,
+                        mimeType,
+                        uri: permalinkUri,
+                        audience: part.audience
+                    });
+                } else {
+                    const decoder = ( new TextDecoder("utf-8", {
+                        fatal: true
+                    }));
                     try {
                         const text = decoder.decode(data.buffer);
-                        const model = this._register(this.modelService.createModel(text, this.languageService.createById('plaintext'), undefined, true));
                         parts.push({
-                            kind: 'code',
-                            textModel: model,
-                            languageId: model.getLanguageId(),
+                            kind: "code",
+                            data: text,
+                            languageId: "plaintext",
+                            codeBlockIndex: i,
+                            ownerMarkdownPartId: this.codeblocksPartId,
                             options: {
                                 hideToolbar: true,
                                 reserveWidth: 19,
                                 maxHeightInLines: 13,
                                 verticalPadding: 5,
-                                editorOptions: { wordWrap: 'on', readOnly: true }
-                            },
-                            codeBlockInfo: {
-                                codeBlockIndex: i,
-                                codemapperUri: undefined,
-                                elementId: this.context.element.id,
-                                focus: () => { },
-                                ownerMarkdownPartId: this.codeblocksPartId,
-                                uri: model.uri,
-                                chatSessionResource: this.context.element.sessionResource,
-                                uriPromise: Promise.resolve(model.uri)
+                                editorOptions: {
+                                    wordWrap: "on",
+                                    readOnly: true
+                                }
                             }
                         });
-                    }
-                    catch {
+                    } catch {
                         const base64 = ( data.toString());
-                        const model = this._register(this.modelService.createModel(base64, this.languageService.createById('plaintext'), undefined, true));
                         parts.push({
-                            kind: 'code',
-                            textModel: model,
-                            languageId: model.getLanguageId(),
+                            kind: "code",
+                            data: base64,
+                            languageId: "plaintext",
+                            codeBlockIndex: i,
+                            ownerMarkdownPartId: this.codeblocksPartId,
                             options: {
                                 hideToolbar: true,
                                 reserveWidth: 19,
                                 maxHeightInLines: 13,
                                 verticalPadding: 5,
-                                editorOptions: { wordWrap: 'on', readOnly: true }
-                            },
-                            codeBlockInfo: {
-                                codeBlockIndex: i,
-                                codemapperUri: undefined,
-                                elementId: this.context.element.id,
-                                focus: () => { },
-                                ownerMarkdownPartId: this.codeblocksPartId,
-                                uri: model.uri,
-                                chatSessionResource: this.context.element.sessionResource,
-                                uriPromise: Promise.resolve(model.uri)
+                                editorOptions: {
+                                    wordWrap: "on",
+                                    readOnly: true
+                                }
                             }
                         });
                     }
@@ -202,25 +206,17 @@ let ChatToolPostExecuteConfirmationPart = class ChatToolPostExecuteConfirmationP
             }
         }
         if (parts.length > 0) {
-            const outputSubPart = this._register(this.instantiationService.createInstance(ChatToolOutputContentSubPart, this.context, parts));
+            const outputSubPart = this._register(
+                this.instantiationService.createInstance(ChatToolOutputContentSubPart, this.context, parts)
+            );
             this._codeblocks.push(...outputSubPart.codeblocks);
-            this._register(outputSubPart.onDidChangeHeight(() => this._onDidChangeHeight.fire()));
-            outputSubPart.domNode.classList.add('tool-postconfirm-display');
+            outputSubPart.domNode.classList.add("tool-postconfirm-display");
             return outputSubPart.domNode;
         }
-        container.textContent = ( localize(5764, 'No displayable results'));
+        container.textContent = ( localize(6020, "No displayable results"));
         return container;
     }
 };
-ChatToolPostExecuteConfirmationPart = ( __decorate([
-    ( __param(2, IInstantiationService)),
-    ( __param(3, IKeybindingService)),
-    ( __param(4, IModelService)),
-    ( __param(5, ILanguageService)),
-    ( __param(6, IContextKeyService)),
-    ( __param(7, IChatWidgetService)),
-    ( __param(8, ILanguageModelToolsService)),
-    ( __param(9, ILanguageModelToolsConfirmationService))
-], ChatToolPostExecuteConfirmationPart));
+ChatToolPostExecuteConfirmationPart = ( __decorate([( __param(2, IInstantiationService)), ( __param(3, IKeybindingService)), ( __param(4, IContextKeyService)), ( __param(5, IChatWidgetService)), ( __param(6, ILanguageModelToolsService)), ( __param(7, ILanguageModelToolsConfirmationService))], ChatToolPostExecuteConfirmationPart));
 
 export { ChatToolPostExecuteConfirmationPart };

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

@@ -1,8 +1,10 @@
 
 import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
-import { createElement, reset } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { createElement, clearNode, reset } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { renderAsPlaintext } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/markdownRenderer';
 import { status } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/aria/aria';
 import { MarkdownString } from '@codingame/monaco-vscode-api/vscode/vs/base/common/htmlContent';
+import { stripIcons } from '@codingame/monaco-vscode-api/vscode/vs/base/common/iconLabels';
 import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
 import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
 import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
@@ -13,7 +15,14 @@ import { BaseChatToolInvocationSubPart } from './chatToolInvocationSubPart.js';
 import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
 
 let ChatToolProgressSubPart = class ChatToolProgressSubPart extends BaseChatToolInvocationSubPart {
-    constructor(toolInvocation, context, renderer, announcedToolProgressKeys, instantiationService, configurationService) {
+    constructor(
+        toolInvocation,
+        context,
+        renderer,
+        announcedToolProgressKeys,
+        instantiationService,
+        configurationService
+    ) {
         super(toolInvocation);
         this.context = context;
         this.renderer = renderer;
@@ -24,24 +33,31 @@ let ChatToolProgressSubPart = class ChatToolProgressSubPart extends BaseChatTool
         this.domNode = this.createProgressPart();
     }
     createProgressPart() {
-        if (IChatToolInvocation.isComplete(this.toolInvocation) && this.toolIsConfirmed && this.toolInvocation.pastTenseMessage) {
-            const key = this.getAnnouncementKey('complete');
+        const isComplete = IChatToolInvocation.isComplete(this.toolInvocation);
+        if (isComplete && this.toolIsConfirmed && this.toolInvocation.pastTenseMessage) {
+            const key = this.getAnnouncementKey("complete");
             const completionContent = this.toolInvocation.pastTenseMessage ?? this.toolInvocation.invocationMessage;
-            const shouldAnnounce = this.toolInvocation.kind === 'toolInvocation' && this.hasMeaningfulContent(completionContent) ? this.computeShouldAnnounce(key) : false;
+            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');
-            const progressObservable = this.toolInvocation.kind === 'toolInvocation' ? ( this.toolInvocation.state.map(
+        } else {
+            const container = createElement("div");
+            const progressObservable = this.toolInvocation.kind === "toolInvocation" ? ( this.toolInvocation.state.map(
                 (s, r) => s.type === IChatToolInvocation.StateKind.Executing ? s.progress.read(r) : undefined
             )) : undefined;
             this._register(autorun(reader => {
                 const progress = progressObservable?.read(reader);
-                const key = this.getAnnouncementKey('progress');
+                const key = this.getAnnouncementKey("progress");
                 const progressContent = progress?.message ?? this.toolInvocation.invocationMessage;
-                const shouldAnnounce = this.toolInvocation.kind === 'toolInvocation' && this.hasMeaningfulContent(progressContent) ? this.computeShouldAnnounce(key) : false;
+                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);
             }));
@@ -53,17 +69,26 @@ let ChatToolProgressSubPart = class ChatToolProgressSubPart extends BaseChatTool
         return !!c && c.type !== ToolConfirmKind.Denied;
     }
     renderProgressContent(content, shouldAnnounce) {
-        if (typeof content === 'string') {
+        if (typeof content === "string") {
             content = ( new MarkdownString()).appendText(content);
         }
         const progressMessage = {
-            kind: 'progressMessage',
+            kind: "progressMessage",
             content
         };
         if (shouldAnnounce) {
             this.provideScreenReaderStatus(content);
         }
-        return this.instantiationService.createInstance(ChatProgressContentPart, progressMessage, this.renderer, this.context, undefined, true, this.getIcon(), this.toolInvocation);
+        return this.instantiationService.createInstance(
+            ChatProgressContentPart,
+            progressMessage,
+            this.renderer,
+            this.context,
+            undefined,
+            true,
+            this.getIcon(),
+            this.toolInvocation
+        );
     }
     getAnnouncementKey(kind) {
         return `${kind}:${this.toolInvocation.toolCallId}`;
@@ -82,20 +107,19 @@ let ChatToolProgressSubPart = class ChatToolProgressSubPart extends BaseChatTool
         return true;
     }
     provideScreenReaderStatus(content) {
-        const message = typeof content === 'string' ? content : content.value;
+        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;
+        const text = typeof content === "string" ? content : content.value;
         return text.trim().length > 0;
     }
 };
-ChatToolProgressSubPart = ( __decorate([
-    ( __param(4, IInstantiationService)),
-    ( __param(5, IConfigurationService))
-], ChatToolProgressSubPart));
+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 "@codingame/monaco-vscode-api/vscode/vs/platform/markdown/browser/markdownRenderer";
+import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { IChatToolInvocation } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService";
+import { IChatCodeBlockInfo } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat";
+import { IChatContentPartRenderContext } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/widget/chatContentParts/chatContentParts";
+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,67 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { createElement, clearNode, reset } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { MarkdownString } from '@codingame/monaco-vscode-api/vscode/vs/base/common/htmlContent';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { IChatToolInvocation } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService';
+import { ChatProgressContentPart } from '../chatProgressContentPart.js';
+import { BaseChatToolInvocationSubPart } from './chatToolInvocationSubPart.js';
+import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
+
+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 part = reader.store.add(this.instantiationService.createInstance(
+                ChatProgressContentPart,
+                progressMessage,
+                this.renderer,
+                this.context,
+                undefined,
+                true,
+                this.getIcon(),
+                toolInvocation
+            ));
+            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/terminalToolAutoExpand.d.ts

@@ -0,0 +1,57 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
+import type { ICommandDetectionCapability } from "@codingame/monaco-vscode-api/vscode/vs/platform/terminal/common/capabilities/capabilities";
+/**
+ * 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 {
+    /**
+     * The command detection capability to listen for command events.
+     */
+    readonly commandDetection: ICommandDetectionCapability;
+    /**
+     * 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 _dataEventTimeout;
+    private _noDataTimeout;
+    private readonly _onDidRequestExpand;
+    readonly onDidRequestExpand: Event<void>;
+    constructor(_options: ITerminalToolAutoExpandOptions);
+    private _setupListeners;
+    private _clearAutoExpandTimeouts;
+}

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

@@ -0,0 +1,69 @@
+
+import { Disposable, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { disposableTimeout } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+
+var TerminalToolAutoExpandTimeout;
+(function(TerminalToolAutoExpandTimeout) {
+    TerminalToolAutoExpandTimeout[TerminalToolAutoExpandTimeout["NoData"] = 500] = "NoData";
+    TerminalToolAutoExpandTimeout[TerminalToolAutoExpandTimeout["DataEvent"] = 50] = "DataEvent";
+})(TerminalToolAutoExpandTimeout || (TerminalToolAutoExpandTimeout = {}));
+class TerminalToolAutoExpand extends Disposable {
+    constructor(_options) {
+        super();
+        this._options = _options;
+        this._commandFinished = false;
+        this._receivedData = false;
+        this._onDidRequestExpand = this._register(( new Emitter()));
+        this.onDidRequestExpand = this._onDidRequestExpand.event;
+        this._setupListeners();
+    }
+    _setupListeners() {
+        const store = this._register(( new DisposableStore()));
+        const commandDetection = this._options.commandDetection;
+        store.add(commandDetection.onCommandExecuted(() => {
+            if (this._options.shouldAutoExpand() && !this._noDataTimeout) {
+                this._noDataTimeout = disposableTimeout(() => {
+                    this._noDataTimeout = undefined;
+                    const shouldExpand = this._options.shouldAutoExpand();
+                    const hasOutput = this._options.hasRealOutput();
+                    if (shouldExpand && hasOutput) {
+                        this._dataEventTimeout?.dispose();
+                        this._dataEventTimeout = undefined;
+                        this._onDidRequestExpand.fire();
+                    }
+                }, TerminalToolAutoExpandTimeout.NoData, store);
+            }
+        }));
+        store.add(this._options.onWillData(() => {
+            if (this._receivedData) {
+                return;
+            }
+            this._receivedData = true;
+            if (this._options.shouldAutoExpand() && !this._dataEventTimeout) {
+                this._dataEventTimeout = disposableTimeout(() => {
+                    this._dataEventTimeout = undefined;
+                    const shouldExpand = this._options.shouldAutoExpand();
+                    const hasOutput = this._options.hasRealOutput();
+                    if (!this._commandFinished && shouldExpand && hasOutput) {
+                        this._noDataTimeout?.dispose();
+                        this._noDataTimeout = undefined;
+                        this._onDidRequestExpand.fire();
+                    }
+                }, TerminalToolAutoExpandTimeout.DataEvent, store);
+            }
+        }));
+        store.add(commandDetection.onCommandFinished(() => {
+            this._commandFinished = true;
+            this._clearAutoExpandTimeouts();
+        }));
+    }
+    _clearAutoExpandTimeouts() {
+        this._dataEventTimeout?.dispose();
+        this._dataEventTimeout = undefined;
+        this._noDataTimeout?.dispose();
+        this._noDataTimeout = undefined;
+    }
+}
+
+export { TerminalToolAutoExpand, TerminalToolAutoExpandTimeout };