@codingame/monaco-vscode-katex-common 24.1.0

package/vscode/src/vs/workbench/contrib/chat/browser/chatContentParts/media/chatThinkingContent.css

@@ -0,0 +1,162 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+.interactive-session .interactive-response .chat-used-context-list.chat-thinking-items {
+	color: var(--vscode-descriptionForeground);
+	padding-top: 0;
+}
+
+.interactive-session .interactive-response .value .chat-thinking-box {
+	outline: none;
+	position: relative;
+	color: var(--vscode-descriptionForeground);
+
+	.chat-used-context {
+		margin: 0px;
+	}
+
+	.monaco-button.hidden,
+	.chat-pinned-preview.hidden {
+		display: none;
+	}
+
+	.chat-used-context-list.chat-thinking-collapsible {
+		border: 1px solid var(--vscode-chat-requestBorder);
+		border-radius: 4px;
+		margin-bottom: 0;
+		position: relative;
+		overflow: hidden;
+
+		.chat-tool-invocation-part {
+			padding: 3px 12px 4px 18px;
+			position: relative;
+
+			.chat-used-context {
+				margin-bottom: 0px;
+				margin-left: 2px;
+				padding-left: 2px;
+			}
+
+			.progress-container {
+				margin: 0 0 2px 6px;
+			}
+
+			.codicon {
+				display: none;
+			}
+		}
+
+		.chat-thinking-item.markdown-content {
+			padding: 5px 12px 6px 24px;
+			position: relative;
+			font-size: var(--vscode-chat-font-size-body-s);
+
+			.progress-container {
+				margin-bottom: 0px;
+				padding-top: 0px;
+			}
+
+			[data-code] {
+				background-color: var(--vscode-textPreformat-background);
+				padding: 1px 3px;
+				border-radius: 4px;
+				white-space: pre-wrap;
+			}
+		}
+
+		/* chain of thought lines */
+		.chat-tool-invocation-part,
+		.chat-thinking-item.markdown-content {
+
+			&::before {
+				content: '';
+				position: absolute;
+				left: 10.5px;
+				top: 0px;
+				bottom: 0px;
+				width: 1px;
+				border-radius: 0;
+				background-color: var(--vscode-chat-requestBorder);
+				mask-image: linear-gradient(to bottom, #000 0 9px, transparent 9px 21px, #000 21px 100%);
+			}
+
+			&:first-child::before {
+				mask-image: linear-gradient(to bottom, transparent 0 21px, #000 21px 100%);
+			}
+
+			&:last-child::before {
+				mask-image: linear-gradient(to bottom, #000 0 9px, transparent 9px 100%);
+			}
+
+			&:only-child::before {
+				background: none;
+				mask-image: none;
+			}
+
+			&::after {
+				content: '';
+				position: absolute;
+				left: 8px;
+				top: 12px;
+				width: 6px;
+				height: 6px;
+				border-radius: 50%;
+				background-color: var(--vscode-chat-requestBorder);
+			}
+
+		}
+	}
+
+	.chat-thinking-item {
+		padding: 6px 12px;
+		position: relative;
+
+		.progress-container {
+			margin-bottom: 0px;
+			padding-top: 0px;
+		}
+	}
+
+	.chat-thinking-text {
+		font-size: var(--vscode-chat-font-size-body-s);
+		padding: 0 10px;
+		display: block;
+	}
+
+	.rendered-markdown > p {
+		margin: 0;
+	}
+}
+
+.interactive-session .interactive-response .value .chat-thinking-fixed-mode {
+	outline: none;
+
+	&.chat-used-context-collapsed .chat-used-context-list.chat-thinking-collapsible.chat-thinking-streaming {
+		max-height: 200px;
+		overflow: hidden;
+		display: block;
+	}
+
+	&:not(.chat-used-context-collapsed) .chat-used-context-list.chat-thinking-collapsible.chat-thinking-streaming {
+		max-height: none;
+		overflow: visible;
+		display: block;
+	}
+
+	.chat-used-context-list.chat-thinking-collapsible:not(.chat-thinking-streaming) {
+		max-height: none;
+		overflow: visible;
+	}
+}
+
+.editor-instance .interactive-session .interactive-response .value .chat-thinking-box .chat-thinking-item ::before {
+	background: var(--vscode-editor-background);
+}
+
+.interactive-session .interactive-response .value .chat-thinking-box .chat-used-context-label code {
+	display: inline;
+	line-height: inherit;
+	padding: 0 4px;
+}

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

@@ -0,0 +1,41 @@
+import { Separator } from "@codingame/monaco-vscode-api/vscode/vs/base/common/actions";
+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";
+import { IKeybindingService } from "@codingame/monaco-vscode-api/vscode/vs/platform/keybinding/common/keybinding.service";
+import { ConfirmedReason, IChatToolInvocation } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService";
+import { ILanguageModelToolsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModelToolsService.service";
+import { IChatWidgetService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service";
+import { IChatConfirmationButton } from "../chatConfirmationWidget.js";
+import { IChatContentPartRenderContext } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chatContentParts/chatContentParts";
+import { BaseChatToolInvocationSubPart } from "./chatToolInvocationSubPart.js";
+export interface IToolConfirmationConfig {
+    allowActionId: string;
+    skipActionId: string;
+    allowLabel: string;
+    skipLabel: string;
+    partType: string;
+    subtitle?: string;
+}
+type AbstractToolPrimaryAction = IChatConfirmationButton<(() => void)> | Separator;
+/**
+ * Base class for a tool confirmation.
+ *
+ * note that implementors MUST call render() after they construct.
+ */
+export declare abstract class AbstractToolConfirmationSubPart extends BaseChatToolInvocationSubPart {
+    protected readonly toolInvocation: IChatToolInvocation;
+    protected readonly context: IChatContentPartRenderContext;
+    protected readonly instantiationService: IInstantiationService;
+    protected readonly keybindingService: IKeybindingService;
+    protected readonly contextKeyService: IContextKeyService;
+    protected readonly chatWidgetService: IChatWidgetService;
+    protected readonly languageModelToolsService: ILanguageModelToolsService;
+    domNode: HTMLElement;
+    constructor(toolInvocation: IChatToolInvocation, context: IChatContentPartRenderContext, instantiationService: IInstantiationService, keybindingService: IKeybindingService, contextKeyService: IContextKeyService, chatWidgetService: IChatWidgetService, languageModelToolsService: ILanguageModelToolsService);
+    protected render(config: IToolConfirmationConfig): void;
+    protected confirmWith(toolInvocation: IChatToolInvocation, reason: ConfirmedReason): void;
+    protected additionalPrimaryActions(): AbstractToolPrimaryAction[];
+    protected abstract createContentElement(): HTMLElement | string;
+    protected abstract getTitle(): string;
+}
+export {};

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

@@ -0,0 +1,94 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
+import { toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+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';
+import { IKeybindingService } from '@codingame/monaco-vscode-api/vscode/vs/platform/keybinding/common/keybinding.service';
+import { ChatContextKeys } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatContextKeys';
+import { ToolConfirmKind, IChatToolInvocation } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService';
+import { ILanguageModelToolsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModelToolsService.service';
+import { IChatWidgetService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service';
+import { ChatCustomConfirmationWidget } from '../chatConfirmationWidget.js';
+import { BaseChatToolInvocationSubPart } from './chatToolInvocationSubPart.js';
+
+let AbstractToolConfirmationSubPart = class AbstractToolConfirmationSubPart extends BaseChatToolInvocationSubPart {
+    constructor(toolInvocation, context, instantiationService, keybindingService, contextKeyService, chatWidgetService, languageModelToolsService) {
+        super(toolInvocation);
+        this.toolInvocation = toolInvocation;
+        this.context = context;
+        this.instantiationService = instantiationService;
+        this.keybindingService = keybindingService;
+        this.contextKeyService = contextKeyService;
+        this.chatWidgetService = chatWidgetService;
+        this.languageModelToolsService = languageModelToolsService;
+        if (toolInvocation.kind !== 'toolInvocation') {
+            throw ( new Error('Confirmation only works with live tool invocations'));
+        }
+    }
+    render(config) {
+        const { keybindingService, languageModelToolsService, toolInvocation } = this;
+        const allowKeybinding = keybindingService.lookupKeybinding(config.allowActionId)?.getLabel();
+        const allowTooltip = allowKeybinding ? `${config.allowLabel} (${allowKeybinding})` : config.allowLabel;
+        const skipKeybinding = keybindingService.lookupKeybinding(config.skipActionId)?.getLabel();
+        const skipTooltip = skipKeybinding ? `${config.skipLabel} (${skipKeybinding})` : config.skipLabel;
+        const additionalActions = this.additionalPrimaryActions();
+        const buttons = [
+            {
+                label: config.allowLabel,
+                tooltip: allowTooltip,
+                data: () => {
+                    this.confirmWith(toolInvocation, { type: ToolConfirmKind.UserAction });
+                },
+                moreActions: additionalActions.length > 0 ? additionalActions : undefined,
+            },
+            {
+                label: ( localize(5127, "Skip")),
+                tooltip: skipTooltip,
+                data: () => {
+                    this.confirmWith(toolInvocation, { type: ToolConfirmKind.Skipped });
+                },
+                isSecondary: true,
+            }
+        ];
+        const contentElement = this.createContentElement();
+        const tool = languageModelToolsService.getTool(toolInvocation.toolId);
+        const confirmWidget = this._register(this.instantiationService.createInstance((ChatCustomConfirmationWidget), this.context, {
+            title: this.getTitle(),
+            icon: tool?.icon && 'id' in tool.icon ? tool.icon : Codicon.tools,
+            subtitle: config.subtitle,
+            buttons,
+            message: contentElement,
+            toolbarData: {
+                arg: toolInvocation,
+                partType: config.partType,
+                partSource: toolInvocation.source.type
+            }
+        }));
+        const hasToolConfirmation = ChatContextKeys.Editing.hasToolConfirmation.bindTo(this.contextKeyService);
+        hasToolConfirmation.set(true);
+        this._register(confirmWidget.onDidClick(button => {
+            button.data();
+            this.chatWidgetService.getWidgetBySessionResource(this.context.element.sessionResource)?.focusInput();
+        }));
+        this._register(confirmWidget.onDidChangeHeight(() => this._onDidChangeHeight.fire()));
+        this._register(toDisposable(() => hasToolConfirmation.reset()));
+        this.domNode = confirmWidget.domNode;
+    }
+    confirmWith(toolInvocation, reason) {
+        IChatToolInvocation.confirmWith(toolInvocation, reason);
+    }
+    additionalPrimaryActions() {
+        return [];
+    }
+};
+AbstractToolConfirmationSubPart = ( __decorate([
+    ( __param(2, IInstantiationService)),
+    ( __param(3, IKeybindingService)),
+    ( __param(4, IContextKeyService)),
+    ( __param(5, IChatWidgetService)),
+    ( __param(6, ILanguageModelToolsService))
+], AbstractToolConfirmationSubPart));
+
+export { AbstractToolConfirmationSubPart };

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

@@ -0,0 +1,15 @@
+import { IContextKeyService } from "@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service";
+import { IExtensionManagementService } from "@codingame/monaco-vscode-api/vscode/vs/platform/extensionManagement/common/extensionManagement.service";
+import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { IKeybindingService } from "@codingame/monaco-vscode-api/vscode/vs/platform/keybinding/common/keybinding.service";
+import { IChatToolInvocation } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService";
+import { IChatWidgetService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service";
+import { IChatContentPartRenderContext } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chatContentParts/chatContentParts";
+import { BaseChatToolInvocationSubPart } from "./chatToolInvocationSubPart.js";
+export declare class ExtensionsInstallConfirmationWidgetSubPart extends BaseChatToolInvocationSubPart {
+    readonly domNode: HTMLElement;
+    private readonly _confirmWidget?;
+    get codeblocks(): import("@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat").IChatCodeBlockInfo[];
+    get codeblocksPartId(): string;
+    constructor(toolInvocation: IChatToolInvocation, context: IChatContentPartRenderContext, keybindingService: IKeybindingService, contextKeyService: IContextKeyService, chatWidgetService: IChatWidgetService, extensionManagementService: IExtensionManagementService, instantiationService: IInstantiationService);
+}

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

@@ -0,0 +1,96 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { $, append } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+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 { IExtensionManagementService } from '@codingame/monaco-vscode-api/vscode/vs/platform/extensionManagement/common/extensionManagement.service';
+import { areSameExtensions } from '@codingame/monaco-vscode-api/vscode/vs/platform/extensionManagement/common/extensionManagementUtil';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { IKeybindingService } from '@codingame/monaco-vscode-api/vscode/vs/platform/keybinding/common/keybinding.service';
+import { ChatContextKeys } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatContextKeys';
+import { IChatToolInvocation, ToolConfirmKind } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService';
+import { AcceptToolConfirmationActionId } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/actions/chatConstants';
+import { CancelChatActionId } from '../../actions/chatExecuteActions.js';
+import { IChatWidgetService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service';
+import { ChatConfirmationWidget } from '../chatConfirmationWidget.js';
+import { ChatExtensionsContentPart } from '../chatExtensionsContentPart.js';
+import { BaseChatToolInvocationSubPart } from './chatToolInvocationSubPart.js';
+
+let ExtensionsInstallConfirmationWidgetSubPart = class ExtensionsInstallConfirmationWidgetSubPart extends BaseChatToolInvocationSubPart {
+    get codeblocks() {
+        return this._confirmWidget?.codeblocks || [];
+    }
+    get codeblocksPartId() {
+        return this._confirmWidget?.codeblocksPartId || '<none>';
+    }
+    constructor(toolInvocation, context, keybindingService, contextKeyService, chatWidgetService, extensionManagementService, instantiationService) {
+        super(toolInvocation);
+        if (toolInvocation.toolSpecificData?.kind !== 'extensions') {
+            throw ( new Error('Tool specific data is missing or not of kind extensions'));
+        }
+        const extensionsContent = toolInvocation.toolSpecificData;
+        this.domNode = $('');
+        const chatExtensionsContentPart = this._register(instantiationService.createInstance(ChatExtensionsContentPart, extensionsContent));
+        this._register(chatExtensionsContentPart.onDidChangeHeight(() => this._onDidChangeHeight.fire()));
+        append(this.domNode, chatExtensionsContentPart.domNode);
+        if (toolInvocation.state.get().type === IChatToolInvocation.StateKind.WaitingForConfirmation) {
+            const allowLabel = ( localize(5128, "Allow"));
+            const allowKeybinding = keybindingService.lookupKeybinding(AcceptToolConfirmationActionId)?.getLabel();
+            const allowTooltip = allowKeybinding ? `${allowLabel} (${allowKeybinding})` : allowLabel;
+            const cancelLabel = ( localize(5129, "Cancel"));
+            const cancelKeybinding = keybindingService.lookupKeybinding(CancelChatActionId)?.getLabel();
+            const cancelTooltip = cancelKeybinding ? `${cancelLabel} (${cancelKeybinding})` : cancelLabel;
+            const enableAllowButtonEvent = this._register(( new Emitter()));
+            const buttons = [
+                {
+                    label: allowLabel,
+                    data: { type: ToolConfirmKind.UserAction },
+                    tooltip: allowTooltip,
+                    disabled: true,
+                    onDidChangeDisablement: enableAllowButtonEvent.event
+                },
+                {
+                    label: cancelLabel,
+                    data: { type: ToolConfirmKind.Denied },
+                    isSecondary: true,
+                    tooltip: cancelTooltip
+                }
+            ];
+            const confirmWidget = this._register(instantiationService.createInstance((ChatConfirmationWidget), context, {
+                title: toolInvocation.confirmationMessages?.title ?? ( localize(5130, "Install Extensions")),
+                message: toolInvocation.confirmationMessages?.message ?? ( localize(
+                    5131,
+                    "Click the Install button on the extension and then press Allow when finished."
+                )),
+                buttons,
+            }));
+            this._confirmWidget = confirmWidget;
+            this._register(confirmWidget.onDidChangeHeight(() => this._onDidChangeHeight.fire()));
+            append(this.domNode, confirmWidget.domNode);
+            this._register(confirmWidget.onDidClick(button => {
+                IChatToolInvocation.confirmWith(toolInvocation, button.data);
+                chatWidgetService.getWidgetBySessionResource(context.element.sessionResource)?.focusInput();
+            }));
+            const hasToolConfirmationKey = ChatContextKeys.Editing.hasToolConfirmation.bindTo(contextKeyService);
+            hasToolConfirmationKey.set(true);
+            this._register(toDisposable(() => hasToolConfirmationKey.reset()));
+            const disposable = this._register(extensionManagementService.onInstallExtension(e => {
+                if (( extensionsContent.extensions.some(id => areSameExtensions({ id }, e.identifier)))) {
+                    disposable.dispose();
+                    enableAllowButtonEvent.fire(false);
+                }
+            }));
+        }
+    }
+};
+ExtensionsInstallConfirmationWidgetSubPart = ( __decorate([
+    ( __param(2, IKeybindingService)),
+    ( __param(3, IContextKeyService)),
+    ( __param(4, IChatWidgetService)),
+    ( __param(5, IExtensionManagementService)),
+    ( __param(6, IInstantiationService))
+], ExtensionsInstallConfirmationWidgetSubPart));
+
+export { ExtensionsInstallConfirmationWidgetSubPart };

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

@@ -0,0 +1,18 @@
+import { IMarkdownString } from "@codingame/monaco-vscode-api/vscode/vs/base/common/htmlContent";
+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 { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { IChatToolInvocation, IChatToolInvocationSerialized } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService";
+import { IToolResultInputOutputDetails } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModelToolsService";
+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/chatContentParts/chatContentParts";
+import { BaseChatToolInvocationSubPart } from "./chatToolInvocationSubPart.js";
+export declare class ChatInputOutputMarkdownProgressPart extends BaseChatToolInvocationSubPart {
+    /** Remembers expanded tool parts on re-render */
+    private static readonly _expandedByDefault;
+    readonly domNode: HTMLElement;
+    private _codeblocks;
+    get codeblocks(): IChatCodeBlockInfo[];
+    constructor(toolInvocation: IChatToolInvocation | IChatToolInvocationSerialized, context: IChatContentPartRenderContext, codeBlockStartIndex: number, message: string | IMarkdownString, subtitle: string | IMarkdownString | undefined, input: string, output: IToolResultInputOutputDetails["output"] | undefined, isError: boolean, instantiationService: IInstantiationService, modelService: IModelService, languageService: ILanguageService);
+    private getAutoApproveMessageContent;
+}

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

@@ -0,0 +1,147 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { ProgressBar } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/progressbar/progressbar';
+import { decodeBase64 } from '@codingame/monaco-vscode-api/vscode/vs/base/common/buffer';
+import { createMarkdownCommandLink, MarkdownString } from '@codingame/monaco-vscode-api/vscode/vs/base/common/htmlContent';
+import { Lazy } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lazy';
+import { toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { getExtensionForMimeType } from '@codingame/monaco-vscode-api/vscode/vs/base/common/mime';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { basename } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+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 { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { ChatResponseResource } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatModel';
+import { IChatToolInvocation, ToolConfirmKind } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService';
+import { ChatCollapsibleInputOutputContentPart } from '../chatToolInputOutputContentPart.js';
+import { BaseChatToolInvocationSubPart } from './chatToolInvocationSubPart.js';
+import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
+
+var ChatInputOutputMarkdownProgressPart_1;
+let ChatInputOutputMarkdownProgressPart = class ChatInputOutputMarkdownProgressPart extends BaseChatToolInvocationSubPart {
+    static { ChatInputOutputMarkdownProgressPart_1 = this; }
+    static { this._expandedByDefault = ( new WeakMap()); }
+    get codeblocks() {
+        return this._codeblocks;
+    }
+    constructor(toolInvocation, context, codeBlockStartIndex, message, subtitle, input, output, isError, instantiationService, modelService, languageService) {
+        super(toolInvocation);
+        this._codeblocks = [];
+        let codeBlockIndex = codeBlockStartIndex;
+        const toCodePart = (data) => {
+            const model = this._register(modelService.createModel(data, languageService.createById('json'), undefined, true));
+            return {
+                kind: 'code',
+                textModel: model,
+                languageId: model.getLanguageId(),
+                options: {
+                    hideToolbar: true,
+                    reserveWidth: 19,
+                    maxHeightInLines: 13,
+                    verticalPadding: 5,
+                    editorOptions: {
+                        wordWrap: 'on'
+                    }
+                },
+                codeBlockInfo: {
+                    codeBlockIndex: codeBlockIndex++,
+                    codemapperUri: undefined,
+                    elementId: context.element.id,
+                    focus: () => { },
+                    ownerMarkdownPartId: this.codeblocksPartId,
+                    uri: model.uri,
+                    chatSessionResource: context.element.sessionResource,
+                    uriPromise: Promise.resolve(model.uri)
+                }
+            };
+        };
+        let processedOutput = output;
+        if (typeof output === 'string') {
+            processedOutput = [{ type: 'embed', value: output, isText: true }];
+        }
+        const collapsibleListPart = this._register(instantiationService.createInstance(ChatCollapsibleInputOutputContentPart, message, subtitle, this.getAutoApproveMessageContent(), context, toCodePart(input), processedOutput && {
+            parts: ( processedOutput.map((o, i) => {
+                const permalinkBasename = o.type === 'ref' || o.uri
+                    ? basename(o.uri)
+                    : o.mimeType && getExtensionForMimeType(o.mimeType)
+                        ? `file${getExtensionForMimeType(o.mimeType)}`
+                        : 'file' + (o.isText ? '.txt' : '.bin');
+                if (o.type === 'ref') {
+                    return { kind: 'data', uri: o.uri, mimeType: o.mimeType };
+                }
+                else if (o.isText && !o.asResource) {
+                    return toCodePart(o.value);
+                }
+                else {
+                    let decoded;
+                    try {
+                        if (!o.isText) {
+                            decoded = decodeBase64(o.value).buffer;
+                        }
+                    }
+                    catch {
+                    }
+                    const permalinkUri = ChatResponseResource.createUri(context.element.sessionResource, toolInvocation.toolCallId, i, permalinkBasename);
+                    return { kind: 'data', value: decoded || ( new TextEncoder()).encode(o.value), mimeType: o.mimeType, uri: permalinkUri, audience: o.audience };
+                }
+            })),
+        }, isError, ChatInputOutputMarkdownProgressPart_1._expandedByDefault.get(toolInvocation) ?? false));
+        this._codeblocks.push(...collapsibleListPart.codeblocks);
+        this._register(collapsibleListPart.onDidChangeHeight(() => this._onDidChangeHeight.fire()));
+        this._register(toDisposable(() => ChatInputOutputMarkdownProgressPart_1._expandedByDefault.set(toolInvocation, collapsibleListPart.expanded)));
+        const progressObservable = toolInvocation.kind === 'toolInvocation' ? ( toolInvocation.state.map(
+            (s, r) => s.type === IChatToolInvocation.StateKind.Executing ? s.progress.read(r) : undefined
+        )) : undefined;
+        const progressBar = ( new Lazy(() => this._register(( new ProgressBar(collapsibleListPart.domNode)))));
+        if (progressObservable) {
+            this._register(autorun(reader => {
+                const progress = progressObservable?.read(reader);
+                if (progress?.message) {
+                    collapsibleListPart.title = progress.message;
+                }
+                if (progress?.progress && !IChatToolInvocation.isComplete(toolInvocation, reader)) {
+                    progressBar.value.setWorked(progress.progress * 100);
+                }
+            }));
+        }
+        this.domNode = collapsibleListPart.domNode;
+    }
+    getAutoApproveMessageContent() {
+        const reason = IChatToolInvocation.executionConfirmedOrDenied(this.toolInvocation);
+        if (!reason || typeof reason === 'boolean') {
+            return;
+        }
+        let md;
+        switch (reason.type) {
+            case ToolConfirmKind.Setting:
+                md = ( localize(
+                    5132,
+                    'Auto approved by {0}',
+                    createMarkdownCommandLink({ title: '`' + reason.id + '`', id: 'workbench.action.openSettings', arguments: [reason.id] }, false)
+                ));
+                break;
+            case ToolConfirmKind.LmServicePerTool:
+                md = reason.scope === 'session'
+                    ? ( localize(5133, 'Auto approved for this session'))
+                    : reason.scope === 'workspace'
+                        ? ( localize(5134, 'Auto approved for this workspace'))
+                        : ( localize(5135, 'Auto approved for this profile'));
+                md += ' (' + createMarkdownCommandLink({ title: ( localize(5136, 'Edit')), id: 'workbench.action.chat.editToolApproval', arguments: [reason.scope] }) + ')';
+                break;
+            case ToolConfirmKind.UserAction:
+            case ToolConfirmKind.Denied:
+            case ToolConfirmKind.ConfirmationNotNeeded:
+            default:
+                return;
+        }
+        return ( new MarkdownString(md, { isTrusted: true }));
+    }
+};
+ChatInputOutputMarkdownProgressPart = ChatInputOutputMarkdownProgressPart_1 = ( __decorate([
+    ( __param(8, IInstantiationService)),
+    ( __param(9, IModelService)),
+    ( __param(10, ILanguageService))
+], ChatInputOutputMarkdownProgressPart));
+
+export { ChatInputOutputMarkdownProgressPart };

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

@@ -0,0 +1,14 @@
+import { IMarkdownString } from "@codingame/monaco-vscode-api/vscode/vs/base/common/htmlContent";
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { Location } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/languages";
+import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { IChatToolInvocation, IChatToolInvocationSerialized } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/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/chatContentParts/chatContentParts";
+import { CollapsibleListPool } from "../chatReferencesContentPart.js";
+import { BaseChatToolInvocationSubPart } from "./chatToolInvocationSubPart.js";
+export declare class ChatResultListSubPart extends BaseChatToolInvocationSubPart {
+    readonly domNode: HTMLElement;
+    readonly codeblocks: IChatCodeBlockInfo[];
+    constructor(toolInvocation: IChatToolInvocation | IChatToolInvocationSerialized, context: IChatContentPartRenderContext, message: string | IMarkdownString, toolDetails: Array<URI | Location>, listPool: CollapsibleListPool, instantiationService: IInstantiationService);
+}

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

@@ -0,0 +1,23 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { ChatCollapsibleListContentPart } from '../chatReferencesContentPart.js';
+import { BaseChatToolInvocationSubPart } from './chatToolInvocationSubPart.js';
+
+let ChatResultListSubPart = class ChatResultListSubPart extends BaseChatToolInvocationSubPart {
+    constructor(toolInvocation, context, message, toolDetails, listPool, instantiationService) {
+        super(toolInvocation);
+        this.codeblocks = [];
+        const collapsibleListPart = this._register(instantiationService.createInstance(ChatCollapsibleListContentPart, ( toolDetails.map(detail => ({
+            kind: 'reference',
+            reference: detail,
+        }))), message, context, listPool));
+        this._register(collapsibleListPart.onDidChangeHeight(() => this._onDidChangeHeight.fire()));
+        this.domNode = collapsibleListPart.domNode;
+    }
+};
+ChatResultListSubPart = ( __decorate([
+    ( __param(5, IInstantiationService))
+], ChatResultListSubPart));
+
+export { ChatResultListSubPart };