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

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

@@ -17,6 +17,39 @@
 		margin: 0px;
 	}
 
+	> .chat-used-context-label .monaco-button.monaco-icon-button {
+		line-height: 1.5em;
+		font-size: 13px;
+
+		.codicon, .monaco-button-mdlabel {
+			font-size: var(--vscode-chat-font-size-body-s);
+		}
+
+		.rendered-markdown.collapsible-title-content {
+			line-height: unset;
+		}
+	}
+
+	/* shimmer animation stuffs */
+	.chat-thinking-spinner-item .chat-thinking-spinner-label {
+		background: linear-gradient(90deg,
+				var(--vscode-descriptionForeground) 0%,
+				var(--vscode-descriptionForeground) 30%,
+				var(--vscode-chat-thinkingShimmer) 50%,
+				var(--vscode-descriptionForeground) 70%,
+				var(--vscode-descriptionForeground) 100%);
+		background-size: 400% 100%;
+		background-clip: text;
+		-webkit-background-clip: text;
+		-webkit-text-fill-color: transparent;
+		animation: chat-thinking-shimmer 2s linear infinite;
+	}
+
+	&:not(.chat-used-context-collapsed) .chat-used-context-list.chat-thinking-collapsible {
+		overflow: visible;
+		max-height: none;
+	}
+
 	.monaco-button.hidden,
 	.chat-pinned-preview.hidden {
 		display: none;
@@ -30,7 +63,7 @@
 		overflow: hidden;
 
 		.chat-tool-invocation-part {
-			padding: 3px 12px 4px 18px;
+			padding: 4px 12px 4px 18px;
 			position: relative;
 
 			.chat-used-context {
@@ -39,17 +72,19 @@
 				padding-left: 2px;
 			}
 
-			.progress-container, .chat-confirmation-widget-container {
+			.progress-container,
+			.chat-confirmation-widget-container {
 				margin: 0 0 2px 6px;
 			}
 
 			.codicon:not(.chat-thinking-icon) {
 				display: none;
 			}
+
 		}
 
 		.chat-thinking-item.markdown-content {
-			padding: 5px 12px 6px 24px;
+			padding: 6px 12px 6px 24px;
 			position: relative;
 			font-size: var(--vscode-chat-font-size-body-s);
 
@@ -67,9 +102,30 @@
 			}
 		}
 
+		.chat-thinking-tool-wrapper .chat-markdown-part.rendered-markdown {
+			padding: 5px 12px 4px 20px;
+
+			.status-icon.codicon-check {
+				display: none;
+			}
+
+			.code:has(.chat-codeblock-pill-container) {
+				margin-bottom: 0px;
+
+				.chat-codeblock-pill-container {
+					margin-bottom: 0px;
+				}
+			}
+		}
+
+		.chat-thinking-tool-wrapper .chat-terminal-thinking-content .chat-markdown-part.rendered-markdown {
+			padding: 0;
+		}
+
 		/* chain of thought lines */
 		.chat-thinking-tool-wrapper,
-		.chat-thinking-item.markdown-content {
+		.chat-thinking-item.markdown-content,
+		.chat-thinking-spinner-item {
 			position: relative;
 
 			&::before {
@@ -109,6 +165,20 @@
 				color: var(--vscode-descriptionForeground);
 			}
 
+			/* the default book icon has a pixel of space at the bottom */
+			> .chat-thinking-icon .codicon.codicon-book {
+				top: 10px;
+			}
+
+		}
+
+		.chat-thinking-spinner-item {
+			padding: 6px 12px 6px 24px;
+			font-size: var(--vscode-chat-font-size-body-s);
+
+			.chat-thinking-spinner-label {
+				color: var(--vscode-descriptionForeground);
+			}
 		}
 	}
 
@@ -133,9 +203,42 @@
 	}
 }
 
+.interactive-session .interactive-response .value .chat-used-context.chat-terminal-thinking-collapsible {
+	display: flex;
+	flex-direction: column;
+	width: 100%;
+
+	.chat-used-context-list.chat-terminal-thinking-content {
+		border: none;
+		padding: 0;
+		margin-bottom: 2px;
+		overflow: hidden;
+
+		.codicon:not(.codicon-check, .codicon-loading) {
+			display: inline-flex;
+		}
+
+		.progress-container {
+			margin: 0;
+		}
+	}
+
+	.chat-terminal-thinking-content .rendered-markdown [data-code] {
+		margin-bottom: 0px;
+	}
+}
+
 .interactive-session .interactive-response .value .chat-thinking-fixed-mode {
 	outline: none;
 
+	> .monaco-scrollable-element > .shadow {
+		display: none;
+	}
+
+	&.chat-used-context-collapsed > .monaco-scrollable-element:has(.chat-used-context-list.chat-thinking-collapsible:not(.chat-thinking-streaming)) {
+		display: none;
+	}
+
 	&.chat-used-context-collapsed .chat-used-context-list.chat-thinking-collapsible.chat-thinking-streaming {
 		max-height: 200px;
 		overflow: hidden;
@@ -148,10 +251,23 @@
 		display: block;
 	}
 
+	&:not(.chat-used-context-collapsed) > .monaco-scrollable-element {
+		overflow: visible;
+		height: auto;
+
+		> .scrollbar {
+			display: none;
+		}
+	}
+
 	.chat-used-context-list.chat-thinking-collapsible:not(.chat-thinking-streaming) {
 		max-height: none;
 		overflow: visible;
 	}
+
+	.chat-thinking-tool-wrapper .chat-used-context:not(.chat-used-context-collapsed) .chat-used-context-list {
+		display: block;
+	}
 }
 
 .editor-instance .interactive-session .interactive-response .value .chat-thinking-box .chat-thinking-item ::before {
@@ -161,5 +277,5 @@
 .interactive-session .interactive-response .value .chat-thinking-box .chat-used-context-label code {
 	display: inline;
 	line-height: inherit;
-	padding: 0 4px;
+	padding: 1px 3px;
 }

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

@@ -0,0 +1,37 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+.interactive-item-container .chat-tip-widget {
+	display: flex;
+	align-items: center;
+	gap: 4px;
+	margin-bottom: 8px;
+	font-size: var(--vscode-chat-font-size-body-s);
+	font-family: var(--vscode-chat-font-family, inherit);
+	color: var(--vscode-descriptionForeground);
+}
+
+.interactive-item-container .chat-tip-widget .codicon-lightbulb {
+	font-size: var(--vscode-chat-font-size-body-s);
+	color: var(--vscode-descriptionForeground);
+}
+
+.interactive-item-container .chat-tip-widget .rendered-markdown p {
+	margin: 0;
+}
+
+/* Override bubble styling for tip widget's rendered markdown in chat editor */
+.interactive-session:not(.chat-widget > .interactive-session) {
+	.interactive-item-container.interactive-request .value .chat-tip-widget .rendered-markdown {
+		background-color: transparent;
+		border-radius: 0;
+		padding: 0;
+		max-width: none;
+		margin-left: 0;
+		width: auto;
+		margin-bottom: 0;
+		position: static;
+	}
+}

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

@@ -14,7 +14,15 @@ import { ChatCustomConfirmationWidget } from '../chatConfirmationWidget.js';
 import { BaseChatToolInvocationSubPart } from './chatToolInvocationSubPart.js';
 
 let AbstractToolConfirmationSubPart = class AbstractToolConfirmationSubPart extends BaseChatToolInvocationSubPart {
-    constructor(toolInvocation, context, instantiationService, keybindingService, contextKeyService, chatWidgetService, languageModelToolsService) {
+    constructor(
+        toolInvocation,
+        context,
+        instantiationService,
+        keybindingService,
+        contextKeyService,
+        chatWidgetService,
+        languageModelToolsService
+    ) {
         super(toolInvocation);
         this.toolInvocation = toolInvocation;
         this.context = context;
@@ -23,56 +31,60 @@ let AbstractToolConfirmationSubPart = class AbstractToolConfirmationSubPart exte
         this.contextKeyService = contextKeyService;
         this.chatWidgetService = chatWidgetService;
         this.languageModelToolsService = languageModelToolsService;
-        if (toolInvocation.kind !== 'toolInvocation') {
-            throw ( new Error('Confirmation only works with live tool invocations'));
+        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 {
+            keybindingService,
+            languageModelToolsService,
+            toolInvocation
+        } = this;
+        const allowTooltip = keybindingService.appendKeybinding(config.allowLabel, config.allowActionId);
+        const skipTooltip = keybindingService.appendKeybinding(config.skipLabel, config.skipActionId);
         const additionalActions = this.additionalPrimaryActions();
-        const buttons = [
-            {
-                label: config.allowLabel,
-                tooltip: allowTooltip,
-                data: () => {
-                    this.confirmWith(toolInvocation, { type: ToolConfirmKind.UserAction });
-                },
-                moreActions: additionalActions.length > 0 ? additionalActions : undefined,
+        const buttons = [{
+            label: config.allowLabel,
+            tooltip: allowTooltip,
+            data: () => {
+                this.confirmWith(toolInvocation, {
+                    type: ToolConfirmKind.UserAction
+                });
             },
-            {
-                label: ( localize(5711, "Skip")),
-                tooltip: skipTooltip,
-                data: () => {
-                    this.confirmWith(toolInvocation, { type: ToolConfirmKind.Skipped });
-                },
-                isSecondary: true,
-            }
-        ];
+            moreActions: additionalActions.length > 0 ? additionalActions : undefined
+        }, {
+            label: ( localize(5960, "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 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;
     }
@@ -83,12 +95,6 @@ let AbstractToolConfirmationSubPart = class AbstractToolConfirmationSubPart exte
         return [];
     }
 };
-AbstractToolConfirmationSubPart = ( __decorate([
-    ( __param(2, IInstantiationService)),
-    ( __param(3, IKeybindingService)),
-    ( __param(4, IContextKeyService)),
-    ( __param(5, IChatWidgetService)),
-    ( __param(6, ILanguageModelToolsService))
-], AbstractToolConfirmationSubPart));
+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/widget/chatContentParts/toolInvocationParts/chatExtensionsInstallToolSubPart.js

@@ -23,51 +23,59 @@ let ExtensionsInstallConfirmationWidgetSubPart = class ExtensionsInstallConfirma
         return this._confirmWidget?.codeblocks || [];
     }
     get codeblocksPartId() {
-        return this._confirmWidget?.codeblocksPartId || '<none>';
+        return this._confirmWidget?.codeblocksPartId || "<none>";
     }
-    constructor(toolInvocation, context, keybindingService, contextKeyService, chatWidgetService, extensionManagementService, instantiationService) {
+    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'));
+        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()));
+        this.domNode = $("");
+        const chatExtensionsContentPart = this._register(
+            instantiationService.createInstance(ChatExtensionsContentPart, extensionsContent)
+        );
         append(this.domNode, chatExtensionsContentPart.domNode);
-        if (toolInvocation.state.get().type === IChatToolInvocation.StateKind.WaitingForConfirmation) {
-            const allowLabel = ( localize(5712, "Allow"));
-            const allowKeybinding = keybindingService.lookupKeybinding(AcceptToolConfirmationActionId)?.getLabel();
-            const allowTooltip = allowKeybinding ? `${allowLabel} (${allowKeybinding})` : allowLabel;
-            const cancelLabel = ( localize(5713, "Cancel"));
-            const cancelKeybinding = keybindingService.lookupKeybinding(CancelChatActionId)?.getLabel();
-            const cancelTooltip = cancelKeybinding ? `${cancelLabel} (${cancelKeybinding})` : cancelLabel;
+        const state = toolInvocation.state.get();
+        if (state.type === IChatToolInvocation.StateKind.WaitingForConfirmation) {
+            const allowLabel = ( localize(5961, "Allow"));
+            const allowTooltip = keybindingService.appendKeybinding(allowLabel, AcceptToolConfirmationActionId);
+            const cancelLabel = ( localize(5962, "Cancel"));
+            const cancelTooltip = keybindingService.appendKeybinding(cancelLabel, CancelChatActionId);
             const enableAllowButtonEvent = this._register(( new Emitter()));
-            const buttons = [
-                {
-                    label: allowLabel,
-                    data: { type: ToolConfirmKind.UserAction },
-                    tooltip: allowTooltip,
-                    disabled: true,
-                    onDidChangeDisablement: enableAllowButtonEvent.event
+            const buttons = [{
+                label: allowLabel,
+                data: {
+                    type: ToolConfirmKind.UserAction
                 },
-                {
-                    label: cancelLabel,
-                    data: { type: ToolConfirmKind.Denied },
-                    isSecondary: true,
-                    tooltip: cancelTooltip
-                }
-            ];
-            const confirmWidget = this._register(instantiationService.createInstance((ChatConfirmationWidget), context, {
-                title: toolInvocation.confirmationMessages?.title ?? ( localize(5714, "Install Extensions")),
-                message: toolInvocation.confirmationMessages?.message ?? ( localize(
-                    5715,
+                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: state.confirmationMessages?.title ?? ( localize(5963, "Install Extensions")),
+                message: state.confirmationMessages?.message ?? ( localize(
+                    5964,
                     "Click the Install button on the extension and then press Allow when finished."
                 )),
-                buttons,
+                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);
@@ -77,7 +85,9 @@ let ExtensionsInstallConfirmationWidgetSubPart = class ExtensionsInstallConfirma
             hasToolConfirmationKey.set(true);
             this._register(toDisposable(() => hasToolConfirmationKey.reset()));
             const disposable = this._register(extensionManagementService.onInstallExtension(e => {
-                if (( extensionsContent.extensions.some(id => areSameExtensions({ id }, e.identifier)))) {
+                if (( extensionsContent.extensions.some(id => areSameExtensions({
+                    id
+                }, e.identifier)))) {
                     disposable.dispose();
                     enableAllowButtonEvent.fire(false);
                 }
@@ -85,12 +95,6 @@ let ExtensionsInstallConfirmationWidgetSubPart = class ExtensionsInstallConfirma
         }
     }
 };
-ExtensionsInstallConfirmationWidgetSubPart = ( __decorate([
-    ( __param(2, IKeybindingService)),
-    ( __param(3, IContextKeyService)),
-    ( __param(4, IChatWidgetService)),
-    ( __param(5, IExtensionManagementService)),
-    ( __param(6, IInstantiationService))
-], ExtensionsInstallConfirmationWidgetSubPart));
+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/widget/chatContentParts/toolInvocationParts/chatInputOutputMarkdownProgressPart.d.ts

@@ -1,6 +1,7 @@
 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 { 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 { IChatToolInvocation, IChatToolInvocationSerialized } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService";
 import { IToolResultInputOutputDetails } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService";
@@ -11,8 +12,9 @@ export declare class ChatInputOutputMarkdownProgressPart extends BaseChatToolInv
     /** Remembers expanded tool parts on re-render */
     private static readonly _expandedByDefault;
     readonly domNode: HTMLElement;
-    private _codeblocks;
+    private readonly collapsibleListPart;
+    private readonly _onDidChangeHeight;
     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);
+    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, configurationService: IConfigurationService);
     private getAutoApproveMessageContent;
 }