@codingame/monaco-vscode-katex-common 26.1.0 → 26.1.2

package/vscode/src/vs/workbench/contrib/chat/browser/widget/chatListRenderer.js

@@ -43,11 +43,11 @@ import { annotateSpecialMarkdownContent, hasCodeblockUriTag, extractSubAgentInvo
 import { checkModeOption } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chat';
 import { ChatContextKeys } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/actions/chatContextKeys';
 import { chatSubcommandLeader } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/requestParser/chatParserTypes';
-import { ChatAgentVoteDirection, IChatToolInvocation, isChatFollowup, ChatErrorLevel, ChatAgentVoteDownReason } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService';
+import { ChatAgentVoteDirection, ChatRequestQueueKind, IChatToolInvocation, isChatFollowup, ChatErrorLevel, ChatAgentVoteDownReason } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService';
 import { IChatService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService.service';
 import { localChatSessionType } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService';
 import { getChatSessionType } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/chatUri';
-import { isResponseVM, isRequestVM } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/chatViewModel';
+import { isResponseVM, isPendingDividerVM, isRequestVM } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/chatViewModel';
 import { getNWords } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/chatWordCounter';
 import { CodeBlockModelCollection } from '../../common/widget/codeBlockModelCollection.js';
 import { ChatAgentLocation, ChatConfiguration, CollapsedToolsDisplayMode, ThinkingDisplayMode } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
@@ -70,6 +70,7 @@ import { ChatQuestionCarouselPart } from './chatContentParts/chatQuestionCarouse
 import { ChatExtensionsContentPart } from './chatContentParts/chatExtensionsContentPart.js';
 import { codeblockHasClosingBackticks, ChatMarkdownContentPart } from './chatContentParts/chatMarkdownContentPart.js';
 import { ChatMcpServersInteractionContentPart } from './chatContentParts/chatMcpServersInteractionContentPart.js';
+import { ChatDisabledClaudeHooksContentPart } from './chatContentParts/chatDisabledClaudeHooksContentPart.js';
 import { ChatMultiDiffContentPart } from './chatContentParts/chatMultiDiffContentPart.js';
 import { ChatWorkingProgressContentPart, ChatProgressContentPart } from './chatContentParts/chatProgressContentPart.js';
 import { ChatPullRequestContentPart } from './chatContentParts/chatPullRequestContentPart.js';
@@ -89,6 +90,8 @@ import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/in
 import { RunSubagentTool } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/builtinTools/runSubagentTool';
 import { isEqual } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
 import { IChatTipService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chatTipService.service';
+import { ChatHookContentPart } from './chatContentParts/chatHookContentPart.js';
+import { HookType } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/hookSchema';
 import { observableValue } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableValue';
 import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
 
@@ -197,6 +200,9 @@ let ChatListItemRenderer = class ChatListItemRenderer extends Disposable {
             }
         }));
     }
+    set pendingDragController(controller) {
+        this._pendingDragController = controller;
+    }
     updateOptions(options) {
         this.rendererOptions = {
             ...this.rendererOptions,
@@ -398,7 +404,7 @@ let ChatListItemRenderer = class ChatListItemRenderer extends Disposable {
         const codiconRestoreContainer = append(checkpointRestoreContainer, $(".codicon-container"));
         append(codiconRestoreContainer, $("span.codicon.codicon-bookmark"));
         const label = append(checkpointRestoreContainer, $("span.checkpoint-label-text"));
-        label.textContent = ( localize(6031, "Checkpoint Restored"));
+        label.textContent = ( localize(6107, "Checkpoint Restored"));
         const checkpointRestoreToolbar = templateDisposables.add(scopedInstantiationService.createInstance(
             MenuWorkbenchToolBar,
             checkpointRestoreContainer,
@@ -557,11 +563,16 @@ let ChatListItemRenderer = class ChatListItemRenderer extends Disposable {
         }
         templateData.currentElement = element;
         this.templateDataByRequestId.set(element.id, templateData);
-        const kind = isRequestVM(element) ? "request" : isResponseVM(element) ? "response" : "welcome";
+        if (isPendingDividerVM(element)) {
+            this.renderPendingDivider(element, templateData);
+            return;
+        }
+        const kind = isRequestVM(element) ? "request" : isResponseVM(element) ? "response" : isPendingDividerVM(element) ? "pendingDivider" : "welcome";
         this.traceLayout("renderElement", `${kind}, index=${index}`);
         ChatContextKeys.isResponse.bindTo(templateData.contextKeyService).set(isResponseVM(element));
         ChatContextKeys.itemId.bindTo(templateData.contextKeyService).set(element.id);
         ChatContextKeys.isRequest.bindTo(templateData.contextKeyService).set(isRequestVM(element));
+        ChatContextKeys.isPendingRequest.bindTo(templateData.contextKeyService).set(isRequestVM(element) && !!element.pendingKind);
         ChatContextKeys.responseDetectedAgentCommand.bindTo(templateData.contextKeyService).set(isResponseVM(element) && element.agentOrSlashCommandDetected);
         if (isResponseVM(element)) {
             ChatContextKeys.responseSupportsIssueReporting.bindTo(templateData.contextKeyService).set(!!element.agent?.metadata.supportIssueReporting);
@@ -588,6 +599,11 @@ let ChatListItemRenderer = class ChatListItemRenderer extends Disposable {
         templateData.rowContainer.classList.toggle("editing-session", location === ChatAgentLocation.Chat);
         templateData.rowContainer.classList.toggle("interactive-request", isRequestVM(element));
         templateData.rowContainer.classList.toggle("interactive-response", isResponseVM(element));
+        templateData.rowContainer.classList.remove("pending-item", "pending-divider", "pending-request");
+        templateData.dragHandle?.remove();
+        templateData.dragHandle = undefined;
+        delete templateData.rowContainer.dataset.pendingRequestId;
+        delete templateData.rowContainer.dataset.pendingKind;
         const progressMessageAtBottomOfResponse = checkModeOption(
             this.delegate.currentChatMode(),
             this.rendererOptions.progressMessageAtBottomOfResponse
@@ -609,8 +625,9 @@ let ChatListItemRenderer = class ChatListItemRenderer extends Disposable {
         }
         templateData.checkpointToolbar.context = element;
         const checkpointEnabled = this.configService.getValue(ChatConfiguration.CheckpointsEnabled) && (this.rendererOptions.restorable ?? true);
-        templateData.checkpointContainer.classList.toggle("hidden", isResponseVM(element) || !checkpointEnabled);
-        const shouldShowRestore = this.viewModel?.model.checkpoint && !this.viewModel?.editing && (index === this.delegate.getListLength() - 1);
+        const isPendingRequest = isRequestVM(element) && !!element.pendingKind;
+        templateData.checkpointContainer.classList.toggle("hidden", isResponseVM(element) || isPendingRequest || !checkpointEnabled);
+        const shouldShowRestore = this.viewModel?.model.checkpoint && !this.viewModel?.editing && (index === this.delegate.getListLength() - 1) && !isPendingRequest;
         templateData.checkpointRestoreContainer.classList.toggle("hidden", !(shouldShowRestore && checkpointEnabled));
         const editing = element.id === this.viewModel?.editing?.id;
         const isInput = this.configService.getValue("chat.editRequests") === "input";
@@ -672,14 +689,40 @@ let ChatListItemRenderer = class ChatListItemRenderer extends Disposable {
         }
         templateData.renderedPartsMounted = true;
     }
+    renderPendingDivider(element, templateData) {
+        templateData.rowContainer.classList.add("pending-item");
+        templateData.rowContainer.classList.add("pending-divider");
+        templateData.rowContainer.classList.remove("interactive-request", "interactive-response", "pending-request");
+        templateData.avatarContainer.classList.add("hidden");
+        templateData.username.classList.add("hidden");
+        templateData.requestHover.classList.add("hidden");
+        templateData.checkpointContainer.classList.add("hidden");
+        templateData.checkpointRestoreContainer.classList.add("hidden");
+        templateData.footerToolbar.getElement().classList.add("hidden");
+        if (templateData.titleToolbar) {
+            templateData.titleToolbar.getElement().classList.add("hidden");
+        }
+        clearNode(templateData.value);
+        clearNode(templateData.detail);
+        const dividerContent = $$1(".pending-divider-content");
+        const label = append(dividerContent, $$1("span.pending-divider-label"));
+        if (element.dividerKind === ChatRequestQueueKind.Steering) {
+            label.textContent = ( localize(6108, "Steering"));
+            label.title = ( localize(6109, "Steering message will be sent after the next tool call happens"));
+        } else {
+            label.textContent = ( localize(6110, "Queued"));
+            label.title = ( localize(6111, "Queued messages will be sent after the current request completes"));
+        }
+        templateData.value.appendChild(dividerContent);
+    }
     renderDetail(element, templateData) {
         clearNode(templateData.detail);
         if (element.agentOrSlashCommandDetected) {
             const msg = element.slashCommand ? ( localize(
-                6032,
+                6112,
                 "used {0} [[(rerun without)]]",
                 `${chatSubcommandLeader}${element.slashCommand.name}`
-            )) : ( localize(6033, "[[(rerun without)]]"));
+            )) : ( localize(6113, "[[(rerun without)]]"));
             reset(templateData.detail, renderFormattedText(msg, {
                 actionHandler: {
                     disposables: templateData.elementDisposables,
@@ -692,7 +735,7 @@ let ChatListItemRenderer = class ChatListItemRenderer extends Disposable {
             this.delegate.currentChatMode(),
             this.rendererOptions.progressMessageAtBottomOfResponse
         )) {
-            templateData.detail.textContent = ( localize(6034, "Working"));
+            templateData.detail.textContent = ( localize(6114, "Working"));
         }
     }
     renderConfirmationAction(element, templateData) {
@@ -701,13 +744,23 @@ let ChatListItemRenderer = class ChatListItemRenderer extends Disposable {
             append(templateData.detail, $("span.codicon.codicon-check", {
                 "aria-hidden": "true"
             }));
-            append(templateData.detail, $("span.confirmation-text", undefined, ( localize(6035, "Selected \"{0}\"", element.confirmation))));
+            append(templateData.detail, $("span.confirmation-text", undefined, ( localize(6115, "Selected \"{0}\"", element.confirmation))));
             templateData.header?.classList.remove("header-disabled");
             templateData.header?.classList.add("partially-disabled");
         }
     }
     renderAvatar(element, templateData) {
-        const icon = isResponseVM(element) ? this.getAgentIcon(element.agent?.metadata) : (element.avatarIcon ?? Codicon.account);
+        if (isPendingDividerVM(element)) {
+            return;
+        }
+        let icon;
+        if (isResponseVM(element)) {
+            icon = this.getAgentIcon(element.agent?.metadata);
+        } else if (isRequestVM(element)) {
+            icon = element.avatarIcon ?? Codicon.account;
+        } else {
+            icon = Codicon.account;
+        }
         if (icon instanceof URI) {
             const avatarIcon = $$1("img.icon");
             avatarIcon.src = ( FileAccess.uriToBrowserUri(icon).toString(true));
@@ -801,7 +854,7 @@ let ChatListItemRenderer = class ChatListItemRenderer extends Disposable {
         }
         if (!lastPart || lastPart.kind === "references" || ((lastPart.kind === "toolInvocation" || lastPart.kind === "toolInvocationSerialized") && (IChatToolInvocation.isComplete(lastPart) || lastPart.presentation === "hidden")) || ((lastPart.kind === "textEditGroup" || lastPart.kind === "notebookEditGroup") && lastPart.done && !( partsToRender.some(
             part => part.kind === "toolInvocation" && !IChatToolInvocation.isComplete(part)
-        ))) || (lastPart.kind === "progressTask" && lastPart.deferred.isSettled) || lastPart.kind === "mcpServersStarting") {
+        ))) || (lastPart.kind === "progressTask" && lastPart.deferred.isSettled) || lastPart.kind === "mcpServersStarting" || lastPart.kind === "disabledClaudeHooks" || lastPart.kind === "hook") {
             return true;
         }
         return false;
@@ -821,6 +874,23 @@ let ChatListItemRenderer = class ChatListItemRenderer extends Disposable {
     }
     renderChatRequest(element, index, templateData) {
         templateData.rowContainer.classList.toggle("chat-response-loading", false);
+        templateData.rowContainer.classList.toggle("pending-request", !!element.pendingKind);
+        if (element.pendingKind && this._pendingDragController) {
+            templateData.rowContainer.dataset.pendingRequestId = element.id;
+            templateData.rowContainer.dataset.pendingKind = element.pendingKind;
+            const sameKindCount = (this.viewModel?.model.getPendingRequests() ?? []).filter(p => p.kind === element.pendingKind).length;
+            if (sameKindCount > 1) {
+                const handle = $$1(".chat-pending-drag-handle" + ThemeIcon.asCSSSelector(Codicon.gripper));
+                templateData.rowContainer.prepend(handle);
+                templateData.dragHandle = handle;
+                this._pendingDragController.attachDragHandle(
+                    element,
+                    handle,
+                    templateData.rowContainer,
+                    templateData.elementDisposables
+                );
+            }
+        }
         if (element.id === this.viewModel?.editing?.id) {
             this._onDidRerender.fire(templateData);
         }
@@ -1012,7 +1082,7 @@ let ChatListItemRenderer = class ChatListItemRenderer extends Disposable {
                 }
             };
             const lastThinking = this.getLastThinkingPart(renderedParts);
-            if (lastThinking && (partToRender.kind === "toolInvocation" || partToRender.kind === "toolInvocationSerialized" || partToRender.kind === "markdownContent" || partToRender.kind === "textEditGroup") && this.shouldPinPart(partToRender, element)) {
+            if (lastThinking && (partToRender.kind === "toolInvocation" || partToRender.kind === "toolInvocationSerialized" || partToRender.kind === "markdownContent" || partToRender.kind === "textEditGroup" || partToRender.kind === "hook") && this.shouldPinPart(partToRender, element)) {
                 const newPart = this.renderChatContentPart(partToRender, templateData, context);
                 if (newPart) {
                     renderedParts[contentIndex] = newPart;
@@ -1189,6 +1259,12 @@ let ChatListItemRenderer = class ChatListItemRenderer extends Disposable {
         if (part.kind === "undoStop") {
             return true;
         }
+        if (part.kind === "hook") {
+            if (part.subAgentInvocationId) {
+                return false;
+            }
+            return part.hookType === HookType.PreToolUse || part.hookType === HookType.PostToolUse;
+        }
         if (collapsedToolsMode === CollapsedToolsDisplayMode.Off) {
             return false;
         }
@@ -1389,6 +1465,8 @@ let ChatListItemRenderer = class ChatListItemRenderer extends Disposable {
                     content,
                     this.chatContentMarkdownRenderer
                 );
+            } else if (content.kind === "hook") {
+                return this.renderHookPart(content, context, templateData);
             } else if (content.kind === "markdownContent") {
                 return this.renderMarkdown(content, templateData, context);
             } else if (content.kind === "references") {
@@ -1413,6 +1491,8 @@ let ChatListItemRenderer = class ChatListItemRenderer extends Disposable {
                 return this.renderChangesSummary(content, context, templateData);
             } else if (content.kind === "mcpServersStarting") {
                 return this.renderMcpServersInteractionRequired(content, context, templateData);
+            } else if (content.kind === "disabledClaudeHooks") {
+                return this.renderDisabledClaudeHooks(content, context);
             } else if (content.kind === "thinking") {
                 return this.renderThinkingPart(content, context, templateData);
             } else if (content.kind === "workspaceEdit") {
@@ -1430,7 +1510,7 @@ let ChatListItemRenderer = class ChatListItemRenderer extends Disposable {
                 "ChatListItemRenderer#renderChatContentPart: error rendering content",
                 toErrorMessage(err, true)
             );
-            const errorPart = this.instantiationService.createInstance(ChatErrorContentPart, ChatErrorLevel.Error, ( new MarkdownString(( localize(6036, "Failed to render content")) + `: ${toErrorMessage(err, false)}`)), content, this.chatContentMarkdownRenderer);
+            const errorPart = this.instantiationService.createInstance(ChatErrorContentPart, ChatErrorLevel.Error, ( new MarkdownString(( localize(6116, "Failed to render content")) + `: ${toErrorMessage(err, false)}`)), content, this.chatContentMarkdownRenderer);
             return {
                 dispose: () => errorPart.dispose(),
                 domNode: errorPart.domNode,
@@ -1685,6 +1765,51 @@ let ChatListItemRenderer = class ChatListItemRenderer extends Disposable {
         const part = this.instantiationService.createInstance(ChatExtensionsContentPart, extensionsContent);
         return part;
     }
+    renderHookPart(hookPart, context, templateData) {
+        if (!(hookPart.stopReason || hookPart.systemMessage)) {
+            return this.renderNoContent(other => other.kind === "hook" && other.hookType === hookPart.hookType);
+        }
+        if (hookPart.subAgentInvocationId) {
+            const subagentPart = this.getSubagentPart(templateData.renderedParts, hookPart.subAgentInvocationId);
+            if (subagentPart) {
+                subagentPart.appendHookItem(() => {
+                    const part = this.instantiationService.createInstance(ChatHookContentPart, hookPart, context);
+                    return {
+                        domNode: part.domNode,
+                        disposable: part
+                    };
+                }, hookPart);
+                return this.renderNoContent(
+                    other => other.kind === "hook" && other.hookType === hookPart.hookType && other.subAgentInvocationId === hookPart.subAgentInvocationId
+                );
+            }
+        }
+        const shouldPinToThinking = hookPart.hookType === HookType.PreToolUse || hookPart.hookType === HookType.PostToolUse;
+        if (shouldPinToThinking) {
+            const hookTitle = hookPart.stopReason ? (hookPart.toolDisplayName ? ( localize(6117, "Blocked {0}", hookPart.toolDisplayName)) : ( localize(6118, "Blocked by hook"))) : (hookPart.toolDisplayName ? ( localize(6119, "Used {0}, but received a warning", hookPart.toolDisplayName)) : ( localize(6120, "Tool call received a warning")));
+            let thinkingPart = this.getLastThinkingPart(templateData.renderedParts);
+            if (!thinkingPart) {
+                const newThinking = this.renderThinkingPart({
+                    kind: "thinking"
+                }, context, templateData);
+                if (newThinking instanceof ChatThinkingContentPart) {
+                    thinkingPart = newThinking;
+                }
+            }
+            if (thinkingPart) {
+                thinkingPart.appendItem(() => {
+                    const part = this.instantiationService.createInstance(ChatHookContentPart, hookPart, context);
+                    return {
+                        domNode: part.domNode,
+                        disposable: part
+                    };
+                }, hookTitle, undefined, templateData.value);
+                return thinkingPart;
+            }
+        }
+        const part = this.instantiationService.createInstance(ChatHookContentPart, hookPart, context);
+        return part;
+    }
     renderPullRequestContent(pullRequestContent, context, templateData) {
         const part = this.instantiationService.createInstance(ChatPullRequestContentPart, pullRequestContent);
         return part;
@@ -1718,20 +1843,43 @@ let ChatListItemRenderer = class ChatListItemRenderer extends Disposable {
         this.finalizeCurrentThinkingPart(context, templateData);
         const widget = isResponseVM(context.element) ? this.chatWidgetService.getWidgetBySessionResource(context.element.sessionResource) : undefined;
         const shouldAutoFocus = widget ? widget.getInput() === "" : true;
-        const part = this.instantiationService.createInstance(ChatQuestionCarouselPart, carousel, context, {
-            shouldAutoFocus,
-            onSubmit: async answers => {
-                const answersRecord = answers ? Object.fromEntries(answers) : undefined;
-                if (answersRecord) {
-                    carousel.data = answersRecord;
-                }
-                carousel.isUsed = true;
-                if (isResponseVM(context.element) && carousel.resolveId) {
-                    this.chatService.notifyQuestionCarouselAnswer(context.element.requestId, carousel.resolveId, answersRecord);
-                }
-                this.removeCarouselFromTracking(context, part);
+        const responseId = isResponseVM(context.element) ? context.element.requestId : undefined;
+        const handleSubmit = async (answers, part) => {
+            const answersRecord = answers ? Object.fromEntries(answers) : undefined;
+            if (answersRecord) {
+                carousel.data = answersRecord;
+            }
+            carousel.isUsed = true;
+            if (isResponseVM(context.element) && carousel.resolveId) {
+                this.chatService.notifyQuestionCarouselAnswer(context.element.requestId, carousel.resolveId, answersRecord);
+            }
+            this.removeCarouselFromTracking(context, part);
+            widget?.input.clearQuestionCarousel();
+        };
+        const responseIsComplete = isResponseVM(context.element) && context.element.isComplete;
+        const inputPartHasCarousel = widget?.input.questionCarousel !== undefined;
+        if (carousel.isUsed || responseIsComplete) {
+            if (responseIsComplete && inputPartHasCarousel && responseId) {
+                widget?.input.clearQuestionCarousel(responseId);
             }
+            const part = this.instantiationService.createInstance(ChatQuestionCarouselPart, carousel, context, {
+                shouldAutoFocus: false,
+                onSubmit: async answers => handleSubmit(answers, part)
+            });
+            return part;
+        }
+        const isEditing = !!this.viewModel?.editing;
+        const part = isEditing ? undefined : widget?.input.renderQuestionCarousel(carousel, context, {
+            shouldAutoFocus,
+            onSubmit: async answers => handleSubmit(answers, part)
         });
+        if (!part) {
+            const fallbackPart = this.instantiationService.createInstance(ChatQuestionCarouselPart, carousel, context, {
+                shouldAutoFocus,
+                onSubmit: async answers => handleSubmit(answers, fallbackPart)
+            });
+            return fallbackPart;
+        }
         if (!carousel.isUsed && this.configService.getValue(ChatConfiguration.GlobalAutoApprove)) {
             part.skip();
         }
@@ -1741,12 +1889,26 @@ let ChatListItemRenderer = class ChatListItemRenderer extends Disposable {
                 carousels = ( new Set());
                 this.pendingQuestionCarousels.set(context.element.sessionResource, carousels);
             }
-            carousels.add(part);
-            part.addDisposable({
-                dispose: () => this.removeCarouselFromTracking(context, part)
-            });
+            if (!( carousels.has(part))) {
+                carousels.add(part);
+                part.addDisposable({
+                    dispose: () => this.removeCarouselFromTracking(context, part)
+                });
+            }
         }
-        return part;
+        return this.renderNoContent((other, _followingContent, element) => {
+            if (carousel.isUsed || (isResponseVM(element) && element.isComplete)) {
+                return false;
+            }
+            if (other.kind === "questionCarousel") {
+                const otherCarousel = other;
+                if (carousel.resolveId && otherCarousel.resolveId) {
+                    return carousel.resolveId === otherCarousel.resolveId;
+                }
+                return other === carousel;
+            }
+            return false;
+        });
     }
     removeCarouselFromTracking(context, part) {
         if (isResponseVM(context.element)) {
@@ -1829,7 +1991,7 @@ let ChatListItemRenderer = class ChatListItemRenderer extends Disposable {
                     })
                 );
                 markdownPart.addDisposable(
-                    this.hoverService.setupManagedHover(getDefaultHoverDelegate("element"), markdownPart.domNode, ( localize(6037, "Click to Edit")), {
+                    this.hoverService.setupManagedHover(getDefaultHoverDelegate("element"), markdownPart.domNode, ( localize(6121, "Click to Edit")), {
                         trapFocus: true
                     })
                 );
@@ -1960,6 +2122,9 @@ let ChatListItemRenderer = class ChatListItemRenderer extends Disposable {
     renderMcpServersInteractionRequired(content, context, templateData) {
         return this.instantiationService.createInstance(ChatMcpServersInteractionContentPart, content, context);
     }
+    renderDisabledClaudeHooks(content, context) {
+        return this.instantiationService.createInstance(ChatDisabledClaudeHooksContentPart, context);
+    }
     disposeTemplate(templateData) {
         this.clearRenderedParts(templateData);
         templateData.templateDisposables.dispose();
@@ -1988,15 +2153,15 @@ class ChatListDelegate extends CachedListVirtualDelegate {
     }
 }
 const voteDownDetailLabels = {
-    [ChatAgentVoteDownReason.IncorrectCode]: ( localize(6038, "Suggested incorrect code")),
-    [ChatAgentVoteDownReason.DidNotFollowInstructions]: ( localize(6039, "Didn't follow instructions")),
-    [ChatAgentVoteDownReason.MissingContext]: ( localize(6040, "Missing context")),
-    [ChatAgentVoteDownReason.OffensiveOrUnsafe]: ( localize(6041, "Offensive or unsafe")),
-    [ChatAgentVoteDownReason.PoorlyWrittenOrFormatted]: ( localize(6042, "Poorly written or formatted")),
-    [ChatAgentVoteDownReason.RefusedAValidRequest]: ( localize(6043, "Refused a valid request")),
-    [ChatAgentVoteDownReason.IncompleteCode]: ( localize(6044, "Incomplete code")),
-    [ChatAgentVoteDownReason.WillReportIssue]: ( localize(6045, "Report an issue")),
-    [ChatAgentVoteDownReason.Other]: ( localize(6046, "Other"))
+    [ChatAgentVoteDownReason.IncorrectCode]: ( localize(6122, "Suggested incorrect code")),
+    [ChatAgentVoteDownReason.DidNotFollowInstructions]: ( localize(6123, "Didn't follow instructions")),
+    [ChatAgentVoteDownReason.MissingContext]: ( localize(6124, "Missing context")),
+    [ChatAgentVoteDownReason.OffensiveOrUnsafe]: ( localize(6125, "Offensive or unsafe")),
+    [ChatAgentVoteDownReason.PoorlyWrittenOrFormatted]: ( localize(6126, "Poorly written or formatted")),
+    [ChatAgentVoteDownReason.RefusedAValidRequest]: ( localize(6127, "Refused a valid request")),
+    [ChatAgentVoteDownReason.IncompleteCode]: ( localize(6128, "Incomplete code")),
+    [ChatAgentVoteDownReason.WillReportIssue]: ( localize(6129, "Report an issue")),
+    [ChatAgentVoteDownReason.Other]: ( localize(6130, "Other"))
 };
 let ChatVoteDownButton = class ChatVoteDownButton extends DropdownMenuActionViewItem {
     constructor(

package/vscode/src/vs/workbench/contrib/chat/browser/widget/chatListWidget.js

@@ -34,6 +34,7 @@ import { ChatAccessibilityProvider } from '../accessibility/chatAccessibilityPro
 import { IChatAccessibilityService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service';
 import { ChatListDelegate, ChatListItemRenderer } from './chatListRenderer.js';
 import { ChatEditorOptions } from './chatOptions.js';
+import { ChatPendingDragController } from './chatPendingDragAndDrop.js';
 
 let ChatListWidget = class ChatListWidget extends Disposable {
     get onDidClickRequest() {
@@ -173,6 +174,9 @@ let ChatListWidget = class ChatListWidget extends Disposable {
                 this.chatService.resendRequest(request, sendOptions).catch(e => this.logService.error("FAILED to rerun request", e));
             }
         }));
+        this._renderer.pendingDragController = this._register(
+            scopedInstantiationService.createInstance(ChatPendingDragController, this._container, () => this._viewModel)
+        );
         const styles = options.styles ?? {};
         this._tree = this._register(scopedInstantiationService.createInstance(
             WorkbenchObjectTree,
@@ -311,10 +315,12 @@ let ChatListWidget = class ChatListWidget extends Disposable {
             this._tree.setChildren(null, treeItems, {
                 diffIdentityProvider: {
                     getId: element => {
+                        const baseId = (isRequestVM(element) || isResponseVM(element)) ? element.dataId : element.id;
+                        const disablement = (isRequestVM(element) || isResponseVM(element)) ? element.shouldBeRemovedOnSend : undefined;
                         return (
-                            element.dataId +
+                            baseId +
                             `${isResponseVM(element) && element.renderData ? `_${this._visibleChangeCount}` : ""}` + (isResponseVM(element) ? `_${element.contentReferences.length}` : "") +
-                            `_${element.shouldBeRemovedOnSend ? `${element.shouldBeRemovedOnSend.afterUndoStop || "1"}` : "0"}` +
+                            `_${disablement ? `${disablement.afterUndoStop || "1"}` : "0"}` +
                             `_${editing ? "1" : "0"}` +
                             `_${checkpoint ? "1" : "0"}` +
                             `_setting${this._settingChangeCounter}` + (isRequestVM(element) && element.contentReferences ? `_${element.contentReferences?.length}` : "")
@@ -467,7 +473,10 @@ let ChatListWidget = class ChatListWidget extends Disposable {
             this._container.style.removeProperty("--chat-current-response-min-height");
         } else {
             const secondToLastItem = this._viewModel?.getItems().at(-2);
-            const secondToLastItemHeight = Math.min(secondToLastItem?.currentRenderedHeight ?? 150, 150);
+            const secondToLastItemHeight = Math.min(
+                (isRequestVM(secondToLastItem) || isResponseVM(secondToLastItem)) ? secondToLastItem.currentRenderedHeight ?? 150 : 150,
+                150
+            );
             const lastItemMinHeight = Math.max(contentHeight - (secondToLastItemHeight + 10), 0);
             this._container.style.setProperty("--chat-current-response-min-height", lastItemMinHeight + "px");
             if (lastItemMinHeight !== this._previousLastItemMinHeight) {

package/vscode/src/vs/workbench/contrib/chat/browser/widget/chatPendingDragAndDrop.d.ts

@@ -0,0 +1,27 @@
+import { Disposable, DisposableStore } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IChatService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService.service";
+import { IChatRequestViewModel, IChatViewModel } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/chatViewModel";
+/**
+ * Manages drag-and-drop reordering for pending (steering/queued) chat messages.
+ * Attaches drag handles to pending request rows and uses event delegation on
+ * the list container to handle drop targets, keeping logic isolated from the
+ * renderer itself.
+ */
+export declare class ChatPendingDragController extends Disposable {
+    private readonly _getViewModel;
+    private readonly _chatService;
+    private _dragState;
+    private readonly _insertIndicator;
+    constructor(listContainer: HTMLElement, _getViewModel: () => IChatViewModel | undefined, _chatService: IChatService);
+    /**
+     * Called by the renderer to wire up a drag handle for a pending request row.
+     */
+    attachDragHandle(element: IChatRequestViewModel, handleEl: HTMLElement, rowContainer: HTMLElement, disposables: DisposableStore): void;
+    private _onDragOver;
+    private _onDrop;
+    private _onDragEnd;
+    private _showIndicator;
+    private _hideIndicator;
+    private _findDropTarget;
+    private _reorder;
+}