@codingame/monaco-vscode-katex-common 25.1.1 → 26.0.0

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

@@ -1,20 +1,26 @@
 
 import { registerCss } from '@codingame/monaco-vscode-api/css';
 import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
-import { h, addDisposableListener, EventType, clearNode, getActiveWindow, getComputedStyle } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { h, addDisposableListener, EventType, clearNode, getActiveWindow, getComputedStyle, createTextNode, createElement, $ } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
 import { ActionBar } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/actionbar/actionbar';
 import { MarkdownString, isMarkdownString } from '@codingame/monaco-vscode-api/vscode/vs/base/common/htmlContent';
+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';
+import { ChatConfiguration } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
 import { migrateLegacyTerminalToolSpecificData } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chat';
+import { IChatToolInvocation } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService';
 import { IChatWidgetService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service';
 import { ChatQueryTitlePart } from '../chatConfirmationWidget.js';
 import { ChatMarkdownContentPart } from '../chatMarkdownContentPart.js';
 import { ChatProgressSubPart } from '../chatProgressContentPart.js';
 import { BaseChatToolInvocationSubPart } from './chatToolInvocationSubPart.js';
+import { TerminalToolAutoExpand } from './terminalToolAutoExpand.js';
+import { ChatCollapsibleContentPart } from '../chatCollapsibleContentPart.js';
 import * as chatTerminalToolProgressPart from '../media/chatTerminalToolProgressPart.css';
 import { Action } from '@codingame/monaco-vscode-api/vscode/vs/base/common/actions';
+import { timeout } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
 import { ITerminalChatService, ITerminalService, ITerminalConfigurationService, ITerminalEditorService, ITerminalGroupService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/terminal.service';
-import { Disposable, MutableDisposable, toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { Disposable, MutableDisposable, toDisposable, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
 import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
 import { ThemeIcon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/themables';
 import { getTerminalCommandDecorationTooltip, getTerminalCommandDecorationState, DecorationSelector } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/xterm/decorationStyles';
@@ -60,7 +66,10 @@ let TerminalCommandDecoration = class TerminalCommandDecoration extends Disposab
         super();
         this._options = _options;
         this._hoverService = _hoverService;
-        const decorationElements = h('span.chat-terminal-command-decoration@decoration', { role: 'img', tabIndex: 0 });
+        const decorationElements = h("span.chat-terminal-command-decoration@decoration", {
+            role: "img",
+            tabIndex: 0
+        });
         this._element = decorationElements.decoration;
         this._attachElementToContainer();
     }
@@ -73,9 +82,8 @@ let TerminalCommandDecoration = class TerminalCommandDecoration extends Disposab
         if (!decoration.isConnected || decoration.parentElement !== container) {
             const icon = this._options.getIconElement();
             if (icon && icon.parentElement === container) {
-                icon.insertAdjacentElement('afterend', decoration);
-            }
-            else {
+                icon.insertAdjacentElement("afterend", decoration);
+            } else {
                 container.insertBefore(decoration, container.firstElementChild ?? null);
             }
         }
@@ -87,7 +95,7 @@ let TerminalCommandDecoration = class TerminalCommandDecoration extends Disposab
     _getHoverText() {
         const command = this._options.getResolvedCommand();
         const storedState = this._options.terminalData.terminalCommandState;
-        return getTerminalCommandDecorationTooltip(command, storedState) || '';
+        return getTerminalCommandDecorationTooltip(command, storedState) || "";
     }
     update(command) {
         this._attachElementToContainer();
@@ -107,10 +115,12 @@ let TerminalCommandDecoration = class TerminalCommandDecoration extends Disposab
                 duration: command.duration ?? existingState.duration
             };
             storedState = terminalData.terminalCommandState;
-        }
-        else if (!storedState) {
+        } else if (!storedState) {
             const now = Date.now();
-            terminalData.terminalCommandState = { exitCode: undefined, timestamp: now };
+            terminalData.terminalCommandState = {
+                exitCode: undefined,
+                timestamp: now
+            };
             storedState = terminalData.terminalCommandState;
         }
         const decorationState = getTerminalCommandDecorationState(command, storedState);
@@ -124,17 +134,15 @@ let TerminalCommandDecoration = class TerminalCommandDecoration extends Disposab
         const isInteractive = !decoration.classList.contains(DecorationSelector.Default);
         decoration.tabIndex = isInteractive ? 0 : -1;
         if (isInteractive) {
-            decoration.removeAttribute('aria-disabled');
-        }
-        else {
-            decoration.setAttribute('aria-disabled', 'true');
+            decoration.removeAttribute("aria-disabled");
+        } else {
+            decoration.setAttribute("aria-disabled", "true");
         }
         const hoverText = tooltip || decorationState.hoverMessage;
         if (hoverText) {
-            decoration.setAttribute('aria-label', hoverText);
-        }
-        else {
-            decoration.removeAttribute('aria-label');
+            decoration.setAttribute("aria-label", hoverText);
+        } else {
+            decoration.removeAttribute("aria-label");
         }
     }
     _attachInteractionHandlers(decoration) {
@@ -144,9 +152,7 @@ let TerminalCommandDecoration = class TerminalCommandDecoration extends Disposab
         this._interactionElement = decoration;
     }
 };
-TerminalCommandDecoration = ( __decorate([
-    ( __param(1, IHoverService))
-], TerminalCommandDecoration));
+TerminalCommandDecoration = ( __decorate([( __param(1, IHoverService))], TerminalCommandDecoration));
 let ChatTerminalToolProgressPart = class ChatTerminalToolProgressPart extends BaseChatToolInvocationSubPart {
     get codeblocks() {
         return this.markdownPart?.codeblocks ?? [];
@@ -157,7 +163,23 @@ let ChatTerminalToolProgressPart = class ChatTerminalToolProgressPart extends Ba
     get contentIndex() {
         return this._contentIndex;
     }
-    constructor(toolInvocation, terminalData, context, renderer, editorPool, currentWidthDelegate, codeBlockStartIndex, codeBlockModelCollection, _instantiationService, _terminalChatService, _terminalService, _contextKeyService, _chatWidgetService, _keybindingService) {
+    constructor(
+        toolInvocation,
+        terminalData,
+        context,
+        renderer,
+        editorPool,
+        currentWidthDelegate,
+        codeBlockStartIndex,
+        codeBlockModelCollection,
+        _instantiationService,
+        _terminalChatService,
+        _terminalService,
+        _contextKeyService,
+        _chatWidgetService,
+        _keybindingService,
+        _configurationService
+    ) {
         super(toolInvocation);
         this._instantiationService = _instantiationService;
         this._terminalChatService = _terminalChatService;
@@ -165,25 +187,27 @@ let ChatTerminalToolProgressPart = class ChatTerminalToolProgressPart extends Ba
         this._contextKeyService = _contextKeyService;
         this._chatWidgetService = _chatWidgetService;
         this._keybindingService = _keybindingService;
+        this._configurationService = _configurationService;
         this._showOutputAction = this._register(( new MutableDisposable()));
         this._showOutputActionAdded = false;
         this._focusAction = this._register(( new MutableDisposable()));
+        this._continueInBackgroundAction = this._register(( new MutableDisposable()));
+        this._userToggledOutput = false;
+        this._isInThinkingContainer = false;
         this._elementIndex = context.elementIndex;
         this._contentIndex = context.contentIndex;
         this._sessionResource = context.element.sessionResource;
         terminalData = migrateLegacyTerminalToolSpecificData(terminalData);
         this._terminalData = terminalData;
         this._terminalCommandUri = terminalData.terminalCommandUri ? URI.revive(terminalData.terminalCommandUri) : undefined;
-        this._storedCommandId = this._terminalCommandUri ? ( new URLSearchParams(this._terminalCommandUri.query ?? '')).get('command') ?? undefined : undefined;
-        this._isSerializedInvocation = (toolInvocation.kind === 'toolInvocationSerialized');
-        const elements = h('.chat-terminal-content-part@container', [
-            h('.chat-terminal-content-title@title', [
-                h('.chat-terminal-command-block@commandBlock')
-            ]),
-            h('.chat-terminal-content-message@message')
-        ]);
+        this._storedCommandId = this._terminalCommandUri ? ( new URLSearchParams(this._terminalCommandUri.query ?? "")).get("command") ?? undefined : undefined;
+        this._isSerializedInvocation = (toolInvocation.kind === "toolInvocationSerialized");
+        const elements = h(".chat-terminal-content-part@container", [h(
+            ".chat-terminal-content-title@title",
+            [h(".chat-terminal-command-block@commandBlock")]
+        ), h(".chat-terminal-content-message@message")]);
         this._titleElement = elements.title;
-        const command = (terminalData.commandLine.userEdited ?? terminalData.commandLine.toolEdited ?? terminalData.commandLine.original).trimStart();
+        const command = (terminalData.commandLine.forDisplay ?? terminalData.commandLine.userEdited ?? terminalData.commandLine.toolEdited ?? terminalData.commandLine.original).trimStart();
         this._commandText = command;
         this._terminalOutputContextKey = ChatContextKeys.inChatTerminalToolOutput.bindTo(this._contextKeyService);
         this._decoration = this._register(this._instantiationService.createInstance(TerminalCommandDecoration, {
@@ -192,16 +216,28 @@ let ChatTerminalToolProgressPart = class ChatTerminalToolProgressPart extends Ba
             getIconElement: () => undefined,
             getResolvedCommand: () => this._getResolvedCommand()
         }));
-        const titlePart = this._register(_instantiationService.createInstance(ChatQueryTitlePart, elements.commandBlock, ( new MarkdownString([
-            `\`\`\`${terminalData.language}`,
-            `${command.replaceAll('```', '\\`\\`\\`')}`,
-            `\`\`\``
-        ].join('\n'), { supportThemeIcons: true })), undefined));
+        const displayCommand = terminalData.presentationOverrides?.commandLine ?? command;
+        const displayLanguage = terminalData.presentationOverrides?.language ?? terminalData.language;
+        const titlePart = this._register(
+            _instantiationService.createInstance(ChatQueryTitlePart, elements.commandBlock, ( new MarkdownString([
+                `\`\`\`${displayLanguage}`,
+                `${displayCommand.replaceAll("```", "\\`\\`\\`")}`,
+                `\`\`\``
+            ].join("\n"), {
+                supportThemeIcons: true
+            })), undefined)
+        );
         this._register(titlePart.onDidChangeHeight(() => {
             this._decoration.update();
-            this._onDidChangeHeight.fire();
         }));
-        this._outputView = this._register(this._instantiationService.createInstance(ChatTerminalToolOutputSection, () => this._onDidChangeHeight.fire(), () => this._ensureTerminalInstance(), () => this._getResolvedCommand(), () => this._terminalData.terminalCommandOutput, () => this._commandText, () => this._terminalData.terminalTheme));
+        this._outputView = this._register(this._instantiationService.createInstance(
+            ChatTerminalToolOutputSection,
+            () => this._ensureTerminalInstance(),
+            () => this._getResolvedCommand(),
+            () => this._terminalData.terminalCommandOutput,
+            () => this._commandText,
+            () => this._terminalData.terminalTheme
+        ));
         elements.container.append(this._outputView.domNode);
         this._register(this._outputView.onDidFocus(() => this._handleOutputFocus()));
         this._register(this._outputView.onDidBlur(e => this._handleOutputBlur(e)));
@@ -210,48 +246,96 @@ let ChatTerminalToolProgressPart = class ChatTerminalToolProgressPart extends Ba
             this._focusAction.value?.refreshKeybindingTooltip();
             this._showOutputAction.value?.refreshKeybindingTooltip();
         }));
-        const actionBarEl = h('.chat-terminal-action-bar@actionBar');
+        const actionBarEl = h(".chat-terminal-action-bar@actionBar");
         elements.title.append(actionBarEl.root);
         this._actionBar = this._register(( new ActionBar(actionBarEl.actionBar, {})));
         this._initializeTerminalActions();
         this._terminalService.whenConnected.then(() => this._initializeTerminalActions());
         let pastTenseMessage;
         if (toolInvocation.pastTenseMessage) {
-            pastTenseMessage = `${typeof toolInvocation.pastTenseMessage === 'string' ? toolInvocation.pastTenseMessage : toolInvocation.pastTenseMessage.value}`;
+            pastTenseMessage = `${typeof toolInvocation.pastTenseMessage === "string" ? toolInvocation.pastTenseMessage : toolInvocation.pastTenseMessage.value}`;
         }
         const markdownContent = ( new MarkdownString(pastTenseMessage, {
             supportThemeIcons: true,
-            isTrusted: isMarkdownString(toolInvocation.pastTenseMessage) ? toolInvocation.pastTenseMessage.isTrusted : false,
+            isTrusted: isMarkdownString(toolInvocation.pastTenseMessage) ? toolInvocation.pastTenseMessage.isTrusted : false
         }));
         const chatMarkdownContent = {
-            kind: 'markdownContent',
-            content: markdownContent,
+            kind: "markdownContent",
+            content: markdownContent
         };
         const codeBlockRenderOptions = {
             hideToolbar: true,
             reserveWidth: 19,
             verticalPadding: 5,
             editorOptions: {
-                wordWrap: 'on'
+                wordWrap: "on"
             }
         };
         const markdownOptions = {
             codeBlockRenderOptions,
             accessibilityOptions: pastTenseMessage ? {
-                statusMessage: ( localize(5733, '{0}', stripIcons(pastTenseMessage)))
+                statusMessage: ( localize(5986, "{0}", stripIcons(pastTenseMessage)))
             } : undefined
         };
-        this.markdownPart = this._register(_instantiationService.createInstance(ChatMarkdownContentPart, chatMarkdownContent, context, editorPool, false, codeBlockStartIndex, renderer, {}, currentWidthDelegate(), codeBlockModelCollection, markdownOptions));
-        this._register(this.markdownPart.onDidChangeHeight(() => this._onDidChangeHeight.fire()));
+        this.markdownPart = this._register(_instantiationService.createInstance(
+            ChatMarkdownContentPart,
+            chatMarkdownContent,
+            context,
+            editorPool,
+            false,
+            codeBlockStartIndex,
+            renderer,
+            {},
+            currentWidthDelegate(),
+            codeBlockModelCollection,
+            markdownOptions
+        ));
         elements.message.append(this.markdownPart.domNode);
-        const progressPart = this._register(_instantiationService.createInstance(ChatProgressSubPart, elements.container, this.getIcon(), terminalData.autoApproveInfo));
-        this.domNode = progressPart.domNode;
+        const progressPart = this._register(_instantiationService.createInstance(
+            ChatProgressSubPart,
+            elements.container,
+            this.getIcon(),
+            terminalData.autoApproveInfo
+        ));
         this._decoration.update();
-        if (expandedStateByInvocation.get(toolInvocation)) {
+        const terminalToolsInThinking = this._configurationService.getValue(ChatConfiguration.TerminalToolsInThinking);
+        const requiresConfirmation = toolInvocation.kind === "toolInvocation" && IChatToolInvocation.getConfirmationMessages(toolInvocation);
+        if (terminalToolsInThinking && !requiresConfirmation) {
+            this._isInThinkingContainer = true;
+            this.domNode = this._createCollapsibleWrapper(progressPart.domNode, command, toolInvocation, context);
+        } else {
+            this.domNode = progressPart.domNode;
+        }
+        const hasStoredOutput = !!terminalData.terminalCommandOutput;
+        if (expandedStateByInvocation.get(toolInvocation) || (this._isInThinkingContainer && IChatToolInvocation.isComplete(toolInvocation) && hasStoredOutput)) {
             void this._toggleOutput(true);
         }
         this._register(this._terminalChatService.registerProgressPart(this));
     }
+    _createCollapsibleWrapper(contentElement, commandText, toolInvocation, context) {
+        const maxCommandLength = 50;
+        const truncatedCommand = commandText.length > maxCommandLength ? commandText.substring(0, maxCommandLength) + "..." : commandText;
+        const isComplete = IChatToolInvocation.isComplete(toolInvocation);
+        const autoExpandFailures = this._configurationService.getValue(ChatConfiguration.AutoExpandToolFailures);
+        const hasError = autoExpandFailures && this._terminalData.terminalCommandState?.exitCode !== undefined && this._terminalData.terminalCommandState.exitCode !== 0;
+        const initialExpanded = !isComplete || hasError;
+        const wrapper = this._register(this._instantiationService.createInstance(
+            ChatTerminalThinkingCollapsibleWrapper,
+            truncatedCommand,
+            contentElement,
+            context,
+            initialExpanded,
+            isComplete
+        ));
+        this._thinkingCollapsibleWrapper = wrapper;
+        return wrapper.domNode;
+    }
+    expandCollapsibleWrapper() {
+        this._thinkingCollapsibleWrapper?.expand();
+    }
+    markCollapsibleWrapperComplete() {
+        this._thinkingCollapsibleWrapper?.markComplete();
+    }
     async _initializeTerminalActions() {
         if (this._store.isDisposed) {
             return;
@@ -261,7 +345,7 @@ let ChatTerminalToolProgressPart = class ChatTerminalToolProgressPart extends Ba
             this._addActions();
             return;
         }
-        const attachInstance = async (instance) => {
+        const attachInstance = async instance => {
             if (this._store.isDisposed) {
                 return;
             }
@@ -288,7 +372,7 @@ let ChatTerminalToolProgressPart = class ChatTerminalToolProgressPart extends Ba
             return;
         }
         if (!this._terminalSessionRegistration) {
-            const listener = this._terminalChatService.onDidRegisterTerminalInstanceWithToolSession(async (instance) => {
+            const listener = this._terminalChatService.onDidRegisterTerminalInstanceWithToolSession(async instance => {
                 const registeredInstance = await this._terminalChatService.getTerminalInstanceByToolSessionId(terminalToolSessionId);
                 if (instance !== registeredInstance) {
                     return;
@@ -299,6 +383,12 @@ let ChatTerminalToolProgressPart = class ChatTerminalToolProgressPart extends Ba
             });
             this._terminalSessionRegistration = this._store.add(listener);
         }
+        this._store.add(this._terminalChatService.onDidContinueInBackground(sessionId => {
+            if (sessionId === terminalToolSessionId) {
+                this._terminalData.didContinueInBackground = true;
+                this._removeContinueInBackgroundAction();
+            }
+        }));
     }
     _addActions(terminalInstance, terminalToolSessionId) {
         if (this._store.isDisposed) {
@@ -307,11 +397,35 @@ let ChatTerminalToolProgressPart = class ChatTerminalToolProgressPart extends Ba
         const actionBar = this._actionBar;
         this._removeFocusAction();
         const resolvedCommand = this._getResolvedCommand(terminalInstance);
+        this._removeContinueInBackgroundAction();
         if (terminalInstance) {
             const isTerminalHidden = terminalInstance && terminalToolSessionId ? this._terminalChatService.isBackgroundTerminal(terminalToolSessionId) : false;
-            const focusAction = this._instantiationService.createInstance(FocusChatInstanceAction, terminalInstance, resolvedCommand, this._terminalCommandUri, this._storedCommandId, isTerminalHidden);
+            const focusAction = this._instantiationService.createInstance(
+                FocusChatInstanceAction,
+                terminalInstance,
+                resolvedCommand,
+                this._terminalCommandUri,
+                this._storedCommandId,
+                isTerminalHidden
+            );
             this._focusAction.value = focusAction;
-            actionBar.push(focusAction, { icon: true, label: false, index: 0 });
+            actionBar.push(focusAction, {
+                icon: true,
+                label: false,
+                index: 0
+            });
+            if (terminalToolSessionId && !this._terminalData.isBackground && !this._terminalData.didContinueInBackground) {
+                const isStillRunning = resolvedCommand?.exitCode === undefined && this._terminalData.terminalCommandState?.exitCode === undefined;
+                if (isStillRunning) {
+                    const continueAction = this._instantiationService.createInstance(ContinueInBackgroundAction, terminalToolSessionId);
+                    this._continueInBackgroundAction.value = continueAction;
+                    actionBar.push(continueAction, {
+                        icon: true,
+                        label: false,
+                        index: 0
+                    });
+                }
+            }
         }
         this._ensureShowOutputAction(resolvedCommand);
         this._decoration.update(resolvedCommand);
@@ -327,6 +441,9 @@ let ChatTerminalToolProgressPart = class ChatTerminalToolProgressPart extends Ba
         if (this._store.isDisposed) {
             return;
         }
+        if (this._isInThinkingContainer) {
+            return;
+        }
         const resolvedCommand = command ?? this._getResolvedCommand();
         const hasSnapshot = !!this._terminalData.terminalCommandOutput;
         if (!resolvedCommand && !hasSnapshot) {
@@ -336,8 +453,9 @@ let ChatTerminalToolProgressPart = class ChatTerminalToolProgressPart extends Ba
         if (!showOutputAction) {
             showOutputAction = this._instantiationService.createInstance(ToggleChatTerminalOutputAction, () => this._toggleOutputFromAction());
             this._showOutputAction.value = showOutputAction;
+            const autoExpandFailures = this._configurationService.getValue(ChatConfiguration.AutoExpandToolFailures);
             const exitCode = resolvedCommand?.exitCode ?? this._terminalData.terminalCommandState?.exitCode;
-            if (exitCode) {
+            if (exitCode !== undefined && exitCode !== 0 && autoExpandFailures) {
                 this._toggleOutput(true);
             }
         }
@@ -348,15 +466,17 @@ let ChatTerminalToolProgressPart = class ChatTerminalToolProgressPart extends Ba
             if (existingIndex >= 0 && existingIndex !== actionBar.length() - 1) {
                 actionBar.pull(existingIndex);
                 this._showOutputActionAdded = false;
-            }
-            else if (existingIndex >= 0) {
+            } else if (existingIndex >= 0) {
                 return;
             }
         }
         if (this._showOutputActionAdded) {
             return;
         }
-        actionBar.push([showOutputAction], { icon: true, label: false });
+        actionBar.push([showOutputAction], {
+            icon: true,
+            label: false
+        });
         this._showOutputActionAdded = true;
     }
     _clearCommandAssociation(options) {
@@ -379,32 +499,91 @@ let ChatTerminalToolProgressPart = class ChatTerminalToolProgressPart extends Ba
             this._addActions(terminalInstance, this._terminalData.terminalToolSessionId);
             return resolvedCommand;
         };
-        const attachCommandDetection = async (commandDetection) => {
+        const attachCommandDetection = async commandDetection => {
             commandDetectionListener.clear();
             if (!commandDetection) {
                 await tryResolveCommand();
                 return;
             }
-            commandDetectionListener.value = commandDetection.onCommandFinished(() => {
+            const store = ( new DisposableStore());
+            let receivedDataCount = 0;
+            const hasRealOutput = () => {
+                if (this._terminalData.terminalCommandOutput?.text?.trim()) {
+                    return true;
+                }
+                const command = this._getResolvedCommand(terminalInstance);
+                if (!command?.executedMarker || terminalInstance.isDisposed) {
+                    return false;
+                }
+                const buffer = terminalInstance.xterm?.raw.buffer.active;
+                if (!buffer) {
+                    return false;
+                }
+                const cursorLine = buffer.baseY + buffer.cursorY;
+                if (cursorLine > command.executedMarker.line) {
+                    return true;
+                }
+                return receivedDataCount > 2;
+            };
+            const autoExpand = store.add(( new TerminalToolAutoExpand({
+                commandDetection,
+                onWillData: terminalInstance.onWillData,
+                shouldAutoExpand: () => !this._outputView.isExpanded && !this._userToggledOutput && !this._store.isDisposed && !expandedStateByInvocation.get(this.toolInvocation),
+                hasRealOutput
+            })));
+            store.add(autoExpand.onDidRequestExpand(() => {
+                if (this._isInThinkingContainer) {
+                    this.expandCollapsibleWrapper();
+                }
+                this._toggleOutput(true);
+            }));
+            store.add(terminalInstance.onWillData(() => {
+                receivedDataCount++;
+            }));
+            store.add(commandDetection.onCommandExecuted(() => {
+                this._addActions(terminalInstance, this._terminalData.terminalToolSessionId);
+            }));
+            store.add(commandDetection.onCommandFinished(() => {
                 this._addActions(terminalInstance, this._terminalData.terminalToolSessionId);
                 const resolvedCommand = this._getResolvedCommand(terminalInstance);
+                this.markCollapsibleWrapperComplete();
+                if (resolvedCommand?.exitCode === 0 && this._outputView.isExpanded && !this._userToggledOutput) {
+                    this._toggleOutput(false);
+                }
+                const autoExpandFailures = this._configurationService.getValue(ChatConfiguration.AutoExpandToolFailures);
+                if (autoExpandFailures && resolvedCommand?.exitCode !== undefined && resolvedCommand.exitCode !== 0 && this._thinkingCollapsibleWrapper) {
+                    this.expandCollapsibleWrapper();
+                }
                 if (resolvedCommand?.endMarker) {
                     commandDetectionListener.clear();
                 }
-            });
+            }));
+            commandDetectionListener.value = store;
             const resolvedImmediately = await tryResolveCommand();
             if (resolvedImmediately?.endMarker) {
                 commandDetectionListener.clear();
+                this.markCollapsibleWrapperComplete();
+                if (resolvedImmediately.exitCode === 0 && this._outputView.isExpanded && !this._userToggledOutput) {
+                    this._toggleOutput(false);
+                }
+                const autoExpandFailures = this._configurationService.getValue(ChatConfiguration.AutoExpandToolFailures);
+                if (autoExpandFailures && resolvedImmediately.exitCode !== undefined && resolvedImmediately.exitCode !== 0 && this._thinkingCollapsibleWrapper) {
+                    this.expandCollapsibleWrapper();
+                }
                 return;
             }
         };
         attachCommandDetection(terminalInstance.capabilities.get(TerminalCapability.CommandDetection));
-        this._register(terminalInstance.capabilities.onDidAddCommandDetectionCapability(cd => attachCommandDetection(cd)));
+        this._register(
+            terminalInstance.capabilities.onDidAddCommandDetectionCapability(cd => attachCommandDetection(cd))
+        );
         const instanceListener = this._register(terminalInstance.onDisposed(() => {
             if (this._terminalInstance === terminalInstance) {
                 this._terminalInstance = undefined;
             }
-            this._clearCommandAssociation({ clearPersistentData: true });
+            this._clearCommandAssociation({
+                clearPersistentData: true
+            });
             commandDetectionListener.clear();
             if (!this._store.isDisposed) {
                 this._actionBar.clear();
@@ -430,10 +609,24 @@ let ChatTerminalToolProgressPart = class ChatTerminalToolProgressPart extends Ba
         }
         this._focusAction.clear();
     }
+    _removeContinueInBackgroundAction() {
+        if (this._store.isDisposed) {
+            return;
+        }
+        const actionBar = this._actionBar;
+        const continueAction = this._continueInBackgroundAction.value;
+        if (actionBar && continueAction) {
+            const existingIndex = actionBar.viewItems.findIndex(item => item.action === continueAction);
+            if (existingIndex >= 0) {
+                actionBar.pull(existingIndex);
+            }
+        }
+        this._continueInBackgroundAction.clear();
+    }
     async _toggleOutput(expanded) {
         const didChange = await this._outputView.toggle(expanded);
         const isExpanded = this._outputView.isExpanded;
-        this._titleElement.classList.toggle('chat-terminal-content-title-no-bottom-radius', isExpanded);
+        this._titleElement.classList.toggle("chat-terminal-content-title-no-bottom-radius", isExpanded);
         this._showOutputAction.value?.syncPresentation(isExpanded);
         if (didChange) {
             expandedStateByInvocation.set(this.toolInvocation, isExpanded);
@@ -489,6 +682,7 @@ let ChatTerminalToolProgressPart = class ChatTerminalToolProgressPart extends Ba
         }
     }
     async toggleOutputFromKeyboard() {
+        this._userToggledOutput = true;
         if (!this._outputView.isExpanded) {
             await this._toggleOutput(true);
             this.focusOutput();
@@ -497,6 +691,7 @@ let ChatTerminalToolProgressPart = class ChatTerminalToolProgressPart extends Ba
         await this._collapseOutputAndFocusInput();
     }
     async _toggleOutputFromAction() {
+        this._userToggledOutput = true;
         if (!this._outputView.isExpanded) {
             await this._toggleOutput(true);
             return;
@@ -514,30 +709,51 @@ let ChatTerminalToolProgressPart = class ChatTerminalToolProgressPart extends Ba
             return undefined;
         }
         const commandDetection = instance.capabilities.get(TerminalCapability.CommandDetection);
-        const commands = commandDetection?.commands;
-        if (!commands || commands.length === 0) {
+        if (!commandDetection) {
             return undefined;
         }
-        return commands.find(c => c.id === this._terminalData.terminalCommandId);
+        const targetId = this._terminalData.terminalCommandId;
+        if (!targetId) {
+            return undefined;
+        }
+        const commands = commandDetection.commands;
+        if (commands && commands.length > 0) {
+            const fromHistory = commands.find(c => c.id === targetId);
+            if (fromHistory) {
+                return fromHistory;
+            }
+        }
+        const executing = commandDetection.executingCommandObject;
+        if (executing && executing.id === targetId) {
+            return executing;
+        }
+        return undefined;
     }
 };
-ChatTerminalToolProgressPart = ( __decorate([
-    ( __param(8, IInstantiationService)),
-    ( __param(9, ITerminalChatService)),
-    ( __param(10, ITerminalService)),
-    ( __param(11, IContextKeyService)),
-    ( __param(12, IChatWidgetService)),
-    ( __param(13, IKeybindingService))
-], ChatTerminalToolProgressPart));
+ChatTerminalToolProgressPart = ( __decorate([( __param(8, IInstantiationService)), ( __param(9, ITerminalChatService)), ( __param(10, ITerminalService)), ( __param(11, IContextKeyService)), ( __param(12, IChatWidgetService)), ( __param(13, IKeybindingService)), ( __param(14, IConfigurationService))], ChatTerminalToolProgressPart));
 let ChatTerminalToolOutputSection = class ChatTerminalToolOutputSection extends Disposable {
     get isExpanded() {
-        return this.domNode.classList.contains('expanded');
-    }
-    get onDidFocus() { return this._onDidFocusEmitter.event; }
-    get onDidBlur() { return this._onDidBlurEmitter.event; }
-    constructor(_onDidChangeHeight, _ensureTerminalInstance, _resolveCommand, _getTerminalCommandOutput, _getCommandText, _getStoredTheme, _accessibleViewService, _instantiationService, _terminalConfigurationService, _themeService, _contextKeyService) {
+        return this.domNode.classList.contains("expanded");
+    }
+    get onDidFocus() {
+        return this._onDidFocusEmitter.event;
+    }
+    get onDidBlur() {
+        return this._onDidBlurEmitter.event;
+    }
+    constructor(
+        _ensureTerminalInstance,
+        _resolveCommand,
+        _getTerminalCommandOutput,
+        _getCommandText,
+        _getStoredTheme,
+        _accessibleViewService,
+        _instantiationService,
+        _terminalConfigurationService,
+        _themeService,
+        _contextKeyService
+    ) {
         super();
-        this._onDidChangeHeight = _onDidChangeHeight;
         this._ensureTerminalInstance = _ensureTerminalInstance;
         this._resolveCommand = _resolveCommand;
         this._getTerminalCommandOutput = _getTerminalCommandOutput;
@@ -548,30 +764,39 @@ let ChatTerminalToolOutputSection = class ChatTerminalToolOutputSection extends
         this._terminalConfigurationService = _terminalConfigurationService;
         this._themeService = _themeService;
         this._contextKeyService = _contextKeyService;
+        this._isAtBottom = true;
+        this._isProgrammaticScroll = false;
         this._onDidFocusEmitter = this._register(( new Emitter()));
         this._onDidBlurEmitter = this._register(( new Emitter()));
-        const containerElements = h('.chat-terminal-output-container@container', [
-            h('.chat-terminal-output-body@body', [
-                h('.chat-terminal-output-content@content', [
-                    h('.chat-terminal-output-terminal@terminal'),
-                    h('.chat-terminal-output-empty@empty')
-                ])
-            ])
-        ]);
+        const containerElements = h(".chat-terminal-output-container@container", [h(
+            ".chat-terminal-output-body@body",
+            [h(".chat-terminal-output-content@content", [
+                h(".chat-terminal-output-terminal@terminal"),
+                h(".chat-terminal-output-empty@empty")
+            ])]
+        )]);
         this.domNode = containerElements.container;
-        this.domNode.classList.add('collapsed');
+        this.domNode.classList.add("collapsed");
         this._outputBody = containerElements.body;
         this._contentContainer = containerElements.content;
         this._terminalContainer = containerElements.terminal;
         this._emptyElement = containerElements.empty;
         this._contentContainer.appendChild(this._emptyElement);
-        this._register(addDisposableListener(this.domNode, EventType.FOCUS_IN, () => this._onDidFocusEmitter.fire()));
-        this._register(addDisposableListener(this.domNode, EventType.FOCUS_OUT, event => this._onDidBlurEmitter.fire(event)));
+        this._register(
+            addDisposableListener(this.domNode, EventType.FOCUS_IN, () => this._onDidFocusEmitter.fire())
+        );
+        this._register(addDisposableListener(
+            this.domNode,
+            EventType.FOCUS_OUT,
+            event => this._onDidBlurEmitter.fire(event)
+        ));
         const resizeObserver = ( new ResizeObserver(() => this._handleResize()));
         resizeObserver.observe(this.domNode);
         this._register(toDisposable(() => resizeObserver.disconnect()));
         this._applyBackgroundColor();
-        this._register(this._themeService.onDidColorThemeChange(() => this._applyBackgroundColor()));
+        this._register(
+            this._themeService.onDidColorThemeChange(() => this._applyBackgroundColor())
+        );
     }
     async toggle(expanded) {
         const currentlyExpanded = this.isExpanded;
@@ -581,16 +806,16 @@ let ChatTerminalToolOutputSection = class ChatTerminalToolOutputSection extends
             }
             return false;
         }
-        this._setExpanded(expanded);
         if (!expanded) {
-            this._renderedOutputHeight = undefined;
-            this._onDidChangeHeight();
+            this._setExpanded(false);
+            this._isAtBottom = true;
             return true;
         }
         if (!this._scrollableContainer) {
             await this._createScrollableContainer();
         }
         await this._updateTerminalContent();
+        this._setExpanded(true);
         this._layoutOutput();
         this._scrollOutputToBottom();
         this._scheduleOutputRelayout();
@@ -611,14 +836,12 @@ let ChatTerminalToolOutputSection = class ChatTerminalToolOutputSection extends
         if (!commandText) {
             return;
         }
-        const ariaLabel = ( localize(5734, 'Terminal output for {0}', commandText));
+        const ariaLabel = ( localize(5987, "Terminal output for {0}", commandText));
         const scrollableDomNode = this._scrollableContainer.getDomNode();
-        scrollableDomNode.setAttribute('role', 'region');
+        scrollableDomNode.setAttribute("role", "region");
         const accessibleViewHint = this._accessibleViewService.getOpenAriaHint(AccessibilityVerbositySettingId.TerminalChatOutput);
-        const label = accessibleViewHint
-            ? ariaLabel + ', ' + accessibleViewHint
-            : ariaLabel;
-        scrollableDomNode.setAttribute('aria-label', label);
+        const label = accessibleViewHint ? ariaLabel + ", " + accessibleViewHint : ariaLabel;
+        scrollableDomNode.setAttribute("aria-label", label);
     }
     getCommandAndOutputAsText() {
         const command = this._resolveCommand();
@@ -626,43 +849,69 @@ let ChatTerminalToolOutputSection = class ChatTerminalToolOutputSection extends
         if (!commandText) {
             return undefined;
         }
-        const commandHeader = ( localize(5735, 'Command: {0}', commandText));
+        const commandHeader = ( localize(5988, "Command: {0}", commandText));
         if (command) {
             const rawOutput = command.getOutput();
             if (!rawOutput || rawOutput.trim().length === 0) {
-                return `${commandHeader}\n${( localize(5736, 'No output was produced by the command.'))}`;
+                return `${commandHeader}\n${( localize(5989, "No output was produced by the command."))}`;
             }
-            const lines = rawOutput.split('\n');
-            return `${commandHeader}\n${lines.join('\n').trimEnd()}`;
+            const lines = rawOutput.split("\n");
+            return `${commandHeader}\n${lines.join("\n").trimEnd()}`;
         }
         const snapshot = this._getTerminalCommandOutput();
         if (!snapshot) {
-            return `${commandHeader}\n${( localize(5737, 'Command output is no longer available.'))}`;
+            return `${commandHeader}\n${( localize(5990, "Command output is no longer available."))}`;
         }
-        const plain = removeAnsiEscapeCodes((snapshot.text ?? ''));
+        const plain = removeAnsiEscapeCodes((snapshot.text ?? ""));
         if (!plain.trim().length) {
-            return `${commandHeader}\n${( localize(5736, 'No output was produced by the command.'))}`;
+            return `${commandHeader}\n${( localize(5989, "No output was produced by the command."))}`;
         }
         let outputText = plain.trimEnd();
         if (snapshot.truncated) {
-            outputText += `\n${( localize(5738, 'Output truncated.'))}`;
+            outputText += `\n${( localize(5991, "Output truncated."))}`;
         }
         return `${commandHeader}\n${outputText}`;
     }
     _setExpanded(expanded) {
-        this.domNode.classList.toggle('expanded', expanded);
-        this.domNode.classList.toggle('collapsed', !expanded);
+        this.domNode.classList.toggle("expanded", expanded);
+        this.domNode.classList.toggle("collapsed", !expanded);
     }
     async _createScrollableContainer() {
         this._scrollableContainer = this._register(( new DomScrollableElement(this._outputBody, {
             vertical: ScrollbarVisibility.Hidden,
-            horizontal: ScrollbarVisibility.Auto,
+            horizontal: ScrollbarVisibility.Hidden,
             handleMouseWheel: true
         })));
         const scrollableDomNode = this._scrollableContainer.getDomNode();
         scrollableDomNode.tabIndex = 0;
         this.domNode.appendChild(scrollableDomNode);
         this.updateAriaLabel();
+        this._register(addDisposableListener(this.domNode, EventType.MOUSE_ENTER, () => {
+            this._scrollableContainer?.updateOptions({
+                horizontal: ScrollbarVisibility.Auto
+            });
+        }));
+        this._register(addDisposableListener(this.domNode, EventType.MOUSE_LEAVE, () => {
+            this._scrollableContainer?.updateOptions({
+                horizontal: ScrollbarVisibility.Hidden
+            });
+        }));
+        this._register(addDisposableListener(this.domNode, EventType.FOCUS_IN, () => {
+            this._scrollableContainer?.updateOptions({
+                horizontal: ScrollbarVisibility.Auto
+            });
+        }));
+        this._register(addDisposableListener(this.domNode, EventType.FOCUS_OUT, () => {
+            this._scrollableContainer?.updateOptions({
+                horizontal: ScrollbarVisibility.Hidden
+            });
+        }));
+        this._register(this._scrollableContainer.onScroll(() => {
+            if (this._isProgrammaticScroll) {
+                return;
+            }
+            this._isAtBottom = this._computeIsAtBottom();
+        }));
     }
     async _updateTerminalContent() {
         const liveTerminalInstance = await this._resolveLiveTerminal();
@@ -686,50 +935,88 @@ let ChatTerminalToolOutputSection = class ChatTerminalToolOutputSection extends
             return true;
         }
         await liveTerminalInstance.xtermReadyPromise;
-        if (liveTerminalInstance.isDisposed || !liveTerminalInstance.xterm) {
+        if (this._store.isDisposed || liveTerminalInstance.isDisposed || !liveTerminalInstance.xterm) {
             this._disposeLiveMirror();
             return false;
         }
-        this._mirror = this._register(this._instantiationService.createInstance(DetachedTerminalCommandMirror, liveTerminalInstance.xterm, command));
-        await this._mirror.attach(this._terminalContainer);
-        const result = await this._mirror.renderCommand();
-        if (!result || result.lineCount === 0) {
-            this._showEmptyMessage(( localize(5736, 'No output was produced by the command.')));
+        const mirror = this._register(
+            this._instantiationService.createInstance(DetachedTerminalCommandMirror, liveTerminalInstance.xterm, command)
+        );
+        this._mirror = mirror;
+        this._register(mirror.onDidUpdate(result => {
+            if (result.lineCount && result.lineCount > 0) {
+                this._hideEmptyMessage();
+            }
+            this._layoutOutput(result.lineCount, result.maxColumnWidth);
+            if (this._isAtBottom) {
+                this._scrollOutputToBottom();
+            }
+        }));
+        this._register(mirror.onDidInput(data => {
+            if (!liveTerminalInstance.isDisposed) {
+                liveTerminalInstance.sendText(data, false);
+            }
+        }));
+        await mirror.attach(this._terminalContainer);
+        let result = await mirror.renderCommand();
+        let commandFinished = !!command.endMarker;
+        let hasOutput = result && result.lineCount && result.lineCount > 0;
+        if (!hasOutput) {
+            const maxRetries = 10;
+            for (let retry = 0; retry < maxRetries && !hasOutput; retry++) {
+                await timeout(100);
+                if (this._store.isDisposed) {
+                    return true;
+                }
+                result = await mirror.renderCommand();
+                hasOutput = result && result.lineCount && result.lineCount > 0;
+                commandFinished = !!command.endMarker;
+                if (commandFinished) {
+                    break;
+                }
+            }
         }
-        else {
+        if (!hasOutput) {
+            if (commandFinished) {
+                this._showEmptyMessage(( localize(5989, "No output was produced by the command.")));
+            }
+        } else {
             this._hideEmptyMessage();
         }
-        this._layoutOutput(result?.lineCount ?? 0);
+        this._layoutOutput(result?.lineCount ?? 0, result?.maxColumnWidth);
         return true;
     }
     async _renderSnapshotOutput(snapshot) {
         if (this._snapshotMirror) {
-            this._layoutOutput(snapshot.lineCount ?? 0);
+            this._layoutOutput(snapshot.lineCount ?? 0, this._lastRenderedMaxColumnWidth);
+            return;
+        }
+        if (this._store.isDisposed) {
             return;
         }
         clearNode(this._terminalContainer);
-        this._snapshotMirror = this._register(this._instantiationService.createInstance(DetachedTerminalSnapshotMirror, snapshot, this._getStoredTheme));
+        this._snapshotMirror = this._register(
+            this._instantiationService.createInstance(DetachedTerminalSnapshotMirror, snapshot, this._getStoredTheme)
+        );
         await this._snapshotMirror.attach(this._terminalContainer);
         this._snapshotMirror.setOutput(snapshot);
         const result = await this._snapshotMirror.render();
         const hasText = !!snapshot.text && snapshot.text.length > 0;
         if (hasText) {
             this._hideEmptyMessage();
-        }
-        else {
-            this._showEmptyMessage(( localize(5736, 'No output was produced by the command.')));
+        } else {
+            this._showEmptyMessage(( localize(5989, "No output was produced by the command.")));
         }
         const lineCount = result?.lineCount ?? snapshot.lineCount ?? 0;
-        this._layoutOutput(lineCount);
+        this._layoutOutput(lineCount, result?.maxColumnWidth);
     }
     _renderUnavailableMessage(liveTerminalInstance) {
         clearNode(this._terminalContainer);
         this._lastRenderedLineCount = undefined;
         if (!liveTerminalInstance) {
-            this._showEmptyMessage(( localize(5739, 'Terminal is no longer available.')));
-        }
-        else {
-            this._showEmptyMessage(( localize(5740, 'Command information is not available.')));
+            this._showEmptyMessage(( localize(5992, "Terminal is no longer available.")));
+        } else {
+            this._showEmptyMessage(( localize(5993, "Command information is not available.")));
         }
     }
     async _resolveLiveTerminal() {
@@ -738,13 +1025,13 @@ let ChatTerminalToolOutputSection = class ChatTerminalToolOutputSection extends
     }
     _showEmptyMessage(message) {
         this._emptyElement.textContent = message;
-        this._terminalContainer.classList.add('chat-terminal-output-terminal-no-output');
-        this.domNode.classList.add('chat-terminal-output-container-no-output');
+        this._terminalContainer.classList.add("chat-terminal-output-terminal-no-output");
+        this.domNode.classList.add("chat-terminal-output-container-no-output");
     }
     _hideEmptyMessage() {
-        this._emptyElement.textContent = '';
-        this._terminalContainer.classList.remove('chat-terminal-output-terminal-no-output');
-        this.domNode.classList.remove('chat-terminal-output-container-no-output');
+        this._emptyElement.textContent = "";
+        this._terminalContainer.classList.remove("chat-terminal-output-terminal-no-output");
+        this.domNode.classList.remove("chat-terminal-output-container-no-output");
     }
     _disposeLiveMirror() {
         if (this._mirror) {
@@ -765,26 +1052,30 @@ let ChatTerminalToolOutputSection = class ChatTerminalToolOutputSection extends
         if (this.isExpanded) {
             this._layoutOutput();
             this._scrollOutputToBottom();
-        }
-        else {
+        } else {
             this._scrollableContainer.scanDomNode();
         }
     }
-    _layoutOutput(lineCount) {
+    _layoutOutput(lineCount, maxColumnWidth) {
         if (!this._scrollableContainer) {
             return;
         }
         if (lineCount !== undefined) {
             this._lastRenderedLineCount = lineCount;
-        }
-        else {
+        } else {
             lineCount = this._lastRenderedLineCount;
         }
+        if (maxColumnWidth !== undefined) {
+            this._lastRenderedMaxColumnWidth = maxColumnWidth;
+        } else {
+            maxColumnWidth = this._lastRenderedMaxColumnWidth;
+        }
         this._scrollableContainer.scanDomNode();
         if (!this.isExpanded || lineCount === undefined) {
             return;
         }
         const scrollableDomNode = this._scrollableContainer.getDomNode();
+        this._applyContentWidth(maxColumnWidth);
         const rowHeight = this._computeRowHeightPx();
         const padding = this._getOutputPadding();
         const minHeight = rowHeight * MIN_OUTPUT_ROWS + padding;
@@ -793,31 +1084,68 @@ let ChatTerminalToolOutputSection = class ChatTerminalToolOutputSection extends
         const clampedHeight = Math.min(contentHeight, maxHeight);
         const measuredBodyHeight = Math.max(this._outputBody.clientHeight, minHeight);
         const appliedHeight = Math.min(clampedHeight, measuredBodyHeight);
-        scrollableDomNode.style.height = appliedHeight < maxHeight ? `${appliedHeight}px` : '';
+        scrollableDomNode.style.height = appliedHeight < maxHeight ? `${appliedHeight}px` : "";
         this._scrollableContainer.scanDomNode();
-        if (this._renderedOutputHeight !== appliedHeight) {
-            this._renderedOutputHeight = appliedHeight;
-            this._onDidChangeHeight();
+    }
+    _computeIsAtBottom() {
+        if (!this._scrollableContainer) {
+            return true;
         }
+        const dimensions = this._scrollableContainer.getScrollDimensions();
+        const scrollPosition = this._scrollableContainer.getScrollPosition();
+        const threshold = 5;
+        return scrollPosition.scrollTop >= dimensions.scrollHeight - dimensions.height - threshold;
     }
     _scrollOutputToBottom() {
         if (!this._scrollableContainer) {
             return;
         }
+        this._isProgrammaticScroll = true;
         const dimensions = this._scrollableContainer.getScrollDimensions();
-        this._scrollableContainer.setScrollPosition({ scrollTop: dimensions.scrollHeight });
+        this._scrollableContainer.setScrollPosition({
+            scrollTop: dimensions.scrollHeight
+        });
+        this._isProgrammaticScroll = false;
     }
     _getOutputContentHeight(lineCount, rowHeight, padding) {
         const contentRows = Math.max(lineCount, MIN_OUTPUT_ROWS);
-        const adjustedRows = contentRows + (lineCount > MAX_OUTPUT_ROWS ? 1 : 0);
+        const adjustedRows = contentRows + 1;
         return (adjustedRows * rowHeight) + padding;
     }
     _getOutputPadding() {
         const style = getComputedStyle(this._outputBody);
-        const paddingTop = Number.parseFloat(style.paddingTop || '0');
-        const paddingBottom = Number.parseFloat(style.paddingBottom || '0');
+        const paddingTop = Number.parseFloat(style.paddingTop || "0");
+        const paddingBottom = Number.parseFloat(style.paddingBottom || "0");
         return paddingTop + paddingBottom;
     }
+    _applyContentWidth(maxColumnWidth) {
+        if (!this._scrollableContainer) {
+            return;
+        }
+        const window = getActiveWindow();
+        const font = this._terminalConfigurationService.getFont(window);
+        const charWidth = font.charWidth;
+        if (!charWidth || !maxColumnWidth || maxColumnWidth <= 0) {
+            return;
+        }
+        const horizontalPadding = 24;
+        const cursorWidth = charWidth;
+        const contentWidth = Math.ceil(maxColumnWidth * charWidth) + horizontalPadding + cursorWidth;
+        const parentWidth = this.domNode.parentElement?.clientWidth ?? 0;
+        const scrollableDomNode = this._scrollableContainer.getDomNode();
+        if (parentWidth > 0 && contentWidth < parentWidth) {
+            scrollableDomNode.style.width = `${contentWidth}px`;
+            this._outputBody.style.width = `${contentWidth}px`;
+            this._terminalContainer.style.width = `${contentWidth}px`;
+            this._terminalContainer.classList.add("chat-terminal-output-terminal-clipped");
+        } else {
+            scrollableDomNode.style.width = "";
+            this._outputBody.style.width = "";
+            this._terminalContainer.style.width = "";
+            this._terminalContainer.classList.remove("chat-terminal-output-terminal-clipped");
+        }
+        this._scrollableContainer.scanDomNode();
+    }
     _computeRowHeightPx() {
         const window = getActiveWindow();
         const font = this._terminalConfigurationService.getFont(window);
@@ -838,16 +1166,10 @@ let ChatTerminalToolOutputSection = class ChatTerminalToolOutputSection extends
         }
     }
 };
-ChatTerminalToolOutputSection = ( __decorate([
-    ( __param(6, IAccessibleViewService)),
-    ( __param(7, IInstantiationService)),
-    ( __param(8, ITerminalConfigurationService)),
-    ( __param(9, IThemeService)),
-    ( __param(10, IContextKeyService))
-], ChatTerminalToolOutputSection));
+ChatTerminalToolOutputSection = ( __decorate([( __param(5, IAccessibleViewService)), ( __param(6, IInstantiationService)), ( __param(7, ITerminalConfigurationService)), ( __param(8, IThemeService)), ( __param(9, IContextKeyService))], ChatTerminalToolOutputSection));
 let ToggleChatTerminalOutputAction = class ToggleChatTerminalOutputAction extends Action {
     constructor(_toggle, _keybindingService, _telemetryService) {
-        super(TerminalContribCommandId.ToggleChatTerminalOutput, ( localize(5741, 'Show Output')), ThemeIcon.asClassName(Codicon.chevronRight), true);
+        super(TerminalContribCommandId.ToggleChatTerminalOutput, ( localize(5994, "Show Output")), ThemeIcon.asClassName(Codicon.chevronRight), true);
         this._toggle = _toggle;
         this._keybindingService = _keybindingService;
         this._telemetryService = _telemetryService;
@@ -855,7 +1177,7 @@ let ToggleChatTerminalOutputAction = class ToggleChatTerminalOutputAction extend
         this._updateTooltip();
     }
     async run() {
-        this._telemetryService.publicLog2('terminal/chatToggleOutput', {
+        this._telemetryService.publicLog2("terminal/chatToggleOutput", {
             previousExpanded: this._expanded
         });
         await this._toggle();
@@ -870,27 +1192,37 @@ let ToggleChatTerminalOutputAction = class ToggleChatTerminalOutputAction extend
     }
     _updatePresentation() {
         if (this._expanded) {
-            this.label = ( localize(5742, 'Hide Output'));
+            this.label = ( localize(5995, "Hide Output"));
             this.class = ThemeIcon.asClassName(Codicon.chevronDown);
-        }
-        else {
-            this.label = ( localize(5741, 'Show Output'));
+        } else {
+            this.label = ( localize(5994, "Show Output"));
             this.class = ThemeIcon.asClassName(Codicon.chevronRight);
         }
     }
     _updateTooltip() {
-        const keybinding = this._keybindingService.lookupKeybinding(TerminalContribCommandId.FocusMostRecentChatTerminalOutput);
-        const label = keybinding?.getLabel();
-        this.tooltip = label ? `${this.label} (${label})` : this.label;
+        this.tooltip = this._keybindingService.appendKeybinding(this.label, TerminalContribCommandId.FocusMostRecentChatTerminalOutput);
     }
 };
-ToggleChatTerminalOutputAction = ( __decorate([
-    ( __param(1, IKeybindingService)),
-    ( __param(2, ITelemetryService))
-], ToggleChatTerminalOutputAction));
+ToggleChatTerminalOutputAction = ( __decorate([( __param(1, IKeybindingService)), ( __param(2, ITelemetryService))], ToggleChatTerminalOutputAction));
 let FocusChatInstanceAction = class FocusChatInstanceAction extends Action {
-    constructor(_instance, _command, _commandUri, _commandId, isTerminalHidden, _terminalService, _terminalEditorService, _terminalGroupService, _keybindingService, _telemetryService) {
-        super(TerminalContribCommandId.FocusChatInstanceAction, isTerminalHidden ? ( localize(5743, 'Show and Focus Terminal')) : ( localize(5744, 'Focus Terminal')), ThemeIcon.asClassName(Codicon.openInProduct), true);
+    constructor(
+        _instance,
+        _command,
+        _commandUri,
+        _commandId,
+        isTerminalHidden,
+        _terminalService,
+        _terminalEditorService,
+        _terminalGroupService,
+        _keybindingService,
+        _telemetryService
+    ) {
+        super(
+            TerminalContribCommandId.FocusChatInstanceAction,
+            isTerminalHidden ? ( localize(5996, "Show and Focus Terminal")) : ( localize(5997, "Focus Terminal")),
+            ThemeIcon.asClassName(Codicon.openInProduct),
+            true
+        );
         this._instance = _instance;
         this._command = _command;
         this._commandUri = _commandUri;
@@ -903,18 +1235,17 @@ let FocusChatInstanceAction = class FocusChatInstanceAction extends Action {
         this._updateTooltip();
     }
     async run() {
-        this.label = this._instance?.shellLaunchConfig.hideFromUser ? ( localize(5745, 'Show and Focus Terminal')) : ( localize(5744, 'Focus Terminal'));
+        this.label = this._instance?.shellLaunchConfig.hideFromUser ? ( localize(5998, "Show and Focus Terminal")) : ( localize(5997, "Focus Terminal"));
         this._updateTooltip();
-        let target = 'none';
-        let location = 'panel';
+        let target = "none";
+        let location = "panel";
         if (this._instance) {
-            target = 'instance';
-            location = this._instance.target === TerminalLocation.Editor ? 'editor' : 'panel';
+            target = "instance";
+            location = this._instance.target === TerminalLocation.Editor ? "editor" : "panel";
+        } else if (this._commandUri) {
+            target = "commandUri";
         }
-        else if (this._commandUri) {
-            target = 'commandUri';
-        }
-        this._telemetryService.publicLog2('terminal/chatFocusInstance', {
+        this._telemetryService.publicLog2("terminal/chatFocusInstance", {
             target,
             location
         });
@@ -922,8 +1253,7 @@ let FocusChatInstanceAction = class FocusChatInstanceAction extends Action {
             this._terminalService.setActiveInstance(this._instance);
             if (this._instance.target === TerminalLocation.Editor) {
                 this._terminalEditorService.openEditor(this._instance);
-            }
-            else {
+            } else {
                 await this._terminalGroupService.showPanel(true);
             }
             this._terminalService.setActiveInstance(this._instance);
@@ -956,17 +1286,71 @@ let FocusChatInstanceAction = class FocusChatInstanceAction extends Action {
         return this._command;
     }
     _updateTooltip() {
-        const keybinding = this._keybindingService.lookupKeybinding(TerminalContribCommandId.FocusMostRecentChatTerminal);
-        const label = keybinding?.getLabel();
-        this.tooltip = label ? `${this.label} (${label})` : this.label;
+        this.tooltip = this._keybindingService.appendKeybinding(this.label, TerminalContribCommandId.FocusMostRecentChatTerminal);
+    }
+};
+FocusChatInstanceAction = ( __decorate([( __param(5, ITerminalService)), ( __param(6, ITerminalEditorService)), ( __param(7, ITerminalGroupService)), ( __param(8, IKeybindingService)), ( __param(9, ITelemetryService))], FocusChatInstanceAction));
+let ContinueInBackgroundAction = class ContinueInBackgroundAction extends Action {
+    constructor(_terminalToolSessionId, _terminalChatService) {
+        super(TerminalContribCommandId.ContinueInBackground, ( localize(5999, "Continue in Background")), ThemeIcon.asClassName(Codicon.debugContinue), true);
+        this._terminalToolSessionId = _terminalToolSessionId;
+        this._terminalChatService = _terminalChatService;
+    }
+    async run() {
+        this._terminalChatService.continueInBackground(this._terminalToolSessionId);
+    }
+};
+ContinueInBackgroundAction = ( __decorate([( __param(1, ITerminalChatService))], ContinueInBackgroundAction));
+let ChatTerminalThinkingCollapsibleWrapper = class ChatTerminalThinkingCollapsibleWrapper extends ChatCollapsibleContentPart {
+    constructor(
+        commandText,
+        contentElement,
+        context,
+        initialExpanded,
+        isComplete,
+        hoverService
+    ) {
+        const title = isComplete ? `Ran \`${commandText}\`` : `Running \`${commandText}\``;
+        super(title, context, undefined, hoverService);
+        this._terminalContentElement = contentElement;
+        this._commandText = commandText;
+        this._isComplete = isComplete;
+        this.domNode.classList.add("chat-terminal-thinking-collapsible");
+        this._setCodeFormattedTitle();
+        this.setExpanded(initialExpanded);
+    }
+    _setCodeFormattedTitle() {
+        if (!this._collapseButton) {
+            return;
+        }
+        const labelElement = this._collapseButton.labelElement;
+        labelElement.textContent = "";
+        const prefixText = this._isComplete ? ( localize(6000, "Ran ")) : ( localize(6001, "Running "));
+        const ranText = createTextNode(prefixText);
+        const codeElement = createElement("code");
+        codeElement.textContent = this._commandText;
+        labelElement.appendChild(ranText);
+        labelElement.appendChild(codeElement);
+    }
+    markComplete() {
+        if (this._isComplete) {
+            return;
+        }
+        this._isComplete = true;
+        this._setCodeFormattedTitle();
+    }
+    initContent() {
+        const listWrapper = $(".chat-used-context-list.chat-terminal-thinking-content");
+        listWrapper.appendChild(this._terminalContentElement);
+        return listWrapper;
+    }
+    expand() {
+        this.setExpanded(true);
+    }
+    hasSameContent(_other, _followingContent, _element) {
+        return false;
     }
 };
-FocusChatInstanceAction = ( __decorate([
-    ( __param(5, ITerminalService)),
-    ( __param(6, ITerminalEditorService)),
-    ( __param(7, ITerminalGroupService)),
-    ( __param(8, IKeybindingService)),
-    ( __param(9, ITelemetryService))
-], FocusChatInstanceAction));
+ChatTerminalThinkingCollapsibleWrapper = ( __decorate([( __param(5, IHoverService))], ChatTerminalThinkingCollapsibleWrapper));
 
-export { ChatTerminalToolProgressPart, FocusChatInstanceAction, ToggleChatTerminalOutputAction };
+export { ChatTerminalToolProgressPart, ContinueInBackgroundAction, FocusChatInstanceAction, ToggleChatTerminalOutputAction };