@codingame/monaco-vscode-api 9.0.3 → 10.0.1

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

@@ -8,15 +8,14 @@ import { distinct, coalesce } from '../../../../base/common/arrays.js';
 import { Codicon } from '../../../../base/common/codicons.js';
 import { Emitter } from '../../../../base/common/event.js';
 import { MarkdownString } from '../../../../base/common/htmlContent.js';
-import { KeyCode } from '../../../../base/common/keyCodes.js';
 import { Disposable, dispose, toDisposable, DisposableStore } from '../../../../base/common/lifecycle.js';
 import { ResourceMap } from '../../../../base/common/map.js';
 import { FileAccess } from '../../../../base/common/network.js';
 import { clamp } from '../../../../base/common/numbers.js';
-import '../../../../base/common/observableInternal/derived.js';
 import { autorun } from '../../../../base/common/observableInternal/autorun.js';
-import '../../../../base/common/observableInternal/utils.js';
+import '../../../../base/common/observableInternal/derived.js';
 import '../../../../base/common/cancellation.js';
+import '../../../../base/common/observableInternal/utils.js';
 import { ThemeIcon } from '../../../../base/common/themables.js';
 import { URI } from '../../../../base/common/uri.js';
 import { localize } from '../../../../nls.js';
@@ -33,6 +32,13 @@ import { ServiceCollection } from '../../../../platform/instantiation/common/ser
 import { ILogService } from '../../../../platform/log/common/log.service.js';
 import { ColorScheme } from '../../../../platform/theme/common/theme.js';
 import { IThemeService } from '../../../../platform/theme/common/themeService.service.js';
+import { IWorkbenchIssueService } from '../../issue/common/issue.service.js';
+import { annotateSpecialMarkdownContent } from '../common/annotations.js';
+import { CONTEXT_RESPONSE, CONTEXT_ITEM_ID, CONTEXT_REQUEST, CONTEXT_RESPONSE_DETECTED_AGENT_COMMAND, CONTEXT_CHAT_RESPONSE_SUPPORT_ISSUE_REPORTING, CONTEXT_RESPONSE_VOTE, CONTEXT_RESPONSE_ERROR, CONTEXT_RESPONSE_FILTERED } from '../common/chatContextKeys.js';
+import { chatSubcommandLeader } from '../common/chatParserTypes.js';
+import { ChatAgentVoteDirection, ChatAgentVoteDownReason } from '../common/chatService.js';
+import { isResponseVM, isRequestVM } from '../common/chatViewModel.js';
+import { getNWords } from '../common/chatWordCounter.js';
 import { MarkUnhelpfulActionId } from './actions/chatTitleActions.js';
 import { GeneratingPhrase } from './chat.js';
 import { ChatAgentHover, getChatAgentHoverOptions } from './chatAgentHover.js';
@@ -45,27 +51,19 @@ import { ChatProgressContentPart } from './chatContentParts/chatProgressContentP
 import { CollapsibleListPool, ChatCollapsibleListContentPart } from './chatContentParts/chatReferencesContentPart.js';
 import { ChatTaskContentPart } from './chatContentParts/chatTaskContentPart.js';
 import { DiffEditorPool, ChatTextEditContentPart } from './chatContentParts/chatTextEditContentPart.js';
+import { ChatToolInvocationPart } from './chatContentParts/chatToolInvocationPart.js';
 import { TreePool, ChatTreeContentPart } from './chatContentParts/chatTreeContentPart.js';
 import { ChatWarningContentPart } from './chatContentParts/chatWarningContentPart.js';
-import { ChatFollowups } from './chatFollowups.js';
 import { ChatMarkdownDecorationsRenderer } from './chatMarkdownDecorationsRenderer.js';
 import { ChatMarkdownRenderer } from './chatMarkdownRenderer.js';
 import { ChatCodeBlockContentProvider } from './codeBlockPart.js';
-import { CONTEXT_RESPONSE, CONTEXT_REQUEST, CONTEXT_RESPONSE_DETECTED_AGENT_COMMAND, CONTEXT_CHAT_RESPONSE_SUPPORT_ISSUE_REPORTING, CONTEXT_RESPONSE_VOTE, CONTEXT_RESPONSE_ERROR, CONTEXT_RESPONSE_FILTERED } from '../common/chatContextKeys.js';
-import { chatSubcommandLeader } from '../common/chatParserTypes.js';
-import { ChatAgentVoteDirection, ChatAgentVoteDownReason } from '../common/chatService.js';
-import { isResponseVM, isRequestVM, isWelcomeVM } from '../common/chatViewModel.js';
-import { getNWords } from '../common/chatWordCounter.js';
-import { IWorkbenchIssueService } from '../../issue/common/issue.service.js';
-import { annotateSpecialMarkdownContent } from '../common/annotations.js';
 var ChatListItemRenderer_1;
 const $ = $$1;
 let ChatListItemRenderer = class ChatListItemRenderer extends Disposable {
     static { ChatListItemRenderer_1 = this; }
     static { this.ID = 'item'; }
-    constructor(editorOptions, location, rendererOptions, delegate, codeBlockModelCollection, overflowWidgetsDomNode, instantiationService, configService, logService, contextKeyService, themeService, commandService, hoverService) {
+    constructor(editorOptions, rendererOptions, delegate, codeBlockModelCollection, overflowWidgetsDomNode, instantiationService, configService, logService, contextKeyService, themeService, commandService, hoverService) {
         super();
-        this.location = location;
         this.rendererOptions = rendererOptions;
         this.delegate = delegate;
         this.codeBlockModelCollection = codeBlockModelCollection;
@@ -93,7 +91,7 @@ let ChatListItemRenderer = class ChatListItemRenderer extends Disposable {
         this._editorPool = this._register(this.instantiationService.createInstance(EditorPool, editorOptions, delegate, overflowWidgetsDomNode));
         this._diffEditorPool = this._register(this.instantiationService.createInstance(DiffEditorPool, editorOptions, delegate, overflowWidgetsDomNode));
         this._treePool = this._register(this.instantiationService.createInstance(TreePool, this._onDidChangeVisibility.event));
-        this._contentReferencesListPool = this._register(this.instantiationService.createInstance(CollapsibleListPool, this._onDidChangeVisibility.event));
+        this._contentReferencesListPool = this._register(this.instantiationService.createInstance(CollapsibleListPool, this._onDidChangeVisibility.event, undefined, undefined));
         this._register(this.instantiationService.createInstance(ChatCodeBlockContentProvider));
     }
     get templateId() {
@@ -187,6 +185,32 @@ let ChatListItemRenderer = class ChatListItemRenderer extends Disposable {
         const elementDisposables = ( (new DisposableStore()));
         const contextKeyService = templateDisposables.add(this.contextKeyService.createScoped(rowContainer));
         const scopedInstantiationService = templateDisposables.add(this.instantiationService.createChild(( (new ServiceCollection([IContextKeyService, contextKeyService])))));
+        let titleToolbar;
+        if (this.rendererOptions.noHeader) {
+            header.classList.add('hidden');
+        }
+        else {
+            titleToolbar = templateDisposables.add(scopedInstantiationService.createInstance(MenuWorkbenchToolBar, toolbarParent ?? header, MenuId.ChatMessageTitle, {
+                menuOptions: {
+                    shouldForwardArgs: true
+                },
+                toolbarOptions: {
+                    shouldInlineSubmenu: submenu => submenu.actions.length <= 1
+                },
+            }));
+        }
+        const footerToolbarContainer = append(rowContainer, $('.chat-footer-toolbar'));
+        const footerToolbar = templateDisposables.add(scopedInstantiationService.createInstance(MenuWorkbenchToolBar, footerToolbarContainer, MenuId.ChatMessageFooter, {
+            eventDebounceDelay: 0,
+            menuOptions: { shouldForwardArgs: true },
+            toolbarOptions: { shouldInlineSubmenu: submenu => submenu.actions.length <= 1 },
+            actionViewItemProvider: (action, options) => {
+                if (action instanceof MenuItemAction && action.item.id === MarkUnhelpfulActionId) {
+                    return scopedInstantiationService.createInstance(ChatVoteDownButton, action, options);
+                }
+                return createActionViewItem(scopedInstantiationService, action, options);
+            }
+        }));
         const agentHover = templateDisposables.add(this.instantiationService.createInstance(ChatAgentHover));
         const hoverContent = () => {
             if (isResponseVM(template.currentElement) && template.currentElement.agent && !template.currentElement.agent.isDefault) {
@@ -199,37 +223,17 @@ let ChatListItemRenderer = class ChatListItemRenderer extends Disposable {
         templateDisposables.add(this.hoverService.setupManagedHover(getDefaultHoverDelegate('element'), user, hoverContent, hoverOptions));
         templateDisposables.add(addDisposableListener(user, EventType.KEY_DOWN, e => {
             const ev = ( (new StandardKeyboardEvent(e)));
-            if (ev.equals(KeyCode.Space) || ev.equals(KeyCode.Enter)) {
+            if (ev.equals(10 ) || ev.equals(3 )) {
                 const content = hoverContent();
                 if (content) {
                     this.hoverService.showHover({ content, target: user, trapFocus: true, actions: hoverOptions.actions }, true);
                 }
             }
-            else if (ev.equals(KeyCode.Escape)) {
+            else if (ev.equals(9 )) {
                 this.hoverService.hideHover();
             }
         }));
-        const template = { avatarContainer, username, detail, value, rowContainer, elementDisposables, templateDisposables, contextKeyService, instantiationService: scopedInstantiationService, agentHover };
-        if (this.rendererOptions.noHeader) {
-            header.classList.add('hidden');
-        }
-        else {
-            template.titleToolbar = templateDisposables.add(scopedInstantiationService.createInstance(MenuWorkbenchToolBar, toolbarParent ?? header, MenuId.ChatMessageTitle, {
-                menuOptions: {
-                    shouldForwardArgs: true
-                },
-                toolbarOptions: {
-                    shouldInlineSubmenu: submenu => submenu.actions.length <= 1
-                },
-                actionViewItemProvider: (action, options) => {
-                    const currentElement = template.currentElement;
-                    if (action instanceof MenuItemAction && action.item.id === MarkUnhelpfulActionId && isResponseVM(currentElement)) {
-                        return scopedInstantiationService.createInstance(ChatVoteDownButton, action, options);
-                    }
-                    return createActionViewItem(scopedInstantiationService, action, options);
-                }
-            }));
-        }
+        const template = { avatarContainer, username, detail, value, rowContainer, elementDisposables, templateDisposables, contextKeyService, instantiationService: scopedInstantiationService, agentHover, titleToolbar, footerToolbar };
         return template;
     }
     renderElement(node, index, templateData) {
@@ -242,6 +246,7 @@ let ChatListItemRenderer = class ChatListItemRenderer extends Disposable {
                 'welcome';
         this.traceLayout('renderElement', `${kind}, index=${index}`);
         CONTEXT_RESPONSE.bindTo(templateData.contextKeyService).set(isResponseVM(element));
+        CONTEXT_ITEM_ID.bindTo(templateData.contextKeyService).set(element.id);
         CONTEXT_REQUEST.bindTo(templateData.contextKeyService).set(isRequestVM(element));
         CONTEXT_RESPONSE_DETECTED_AGENT_COMMAND.bindTo(templateData.contextKeyService).set(isResponseVM(element) && element.agentOrSlashCommandDetected);
         if (isResponseVM(element)) {
@@ -254,12 +259,12 @@ let ChatListItemRenderer = class ChatListItemRenderer extends Disposable {
         if (templateData.titleToolbar) {
             templateData.titleToolbar.context = element;
         }
+        templateData.footerToolbar.context = element;
         CONTEXT_RESPONSE_ERROR.bindTo(templateData.contextKeyService).set(isResponseVM(element) && !!element.errorDetails);
         const isFiltered = !!(isResponseVM(element) && element.errorDetails?.responseIsFiltered);
         CONTEXT_RESPONSE_FILTERED.bindTo(templateData.contextKeyService).set(isFiltered);
         templateData.rowContainer.classList.toggle('interactive-request', isRequestVM(element));
         templateData.rowContainer.classList.toggle('interactive-response', isResponseVM(element));
-        templateData.rowContainer.classList.toggle('interactive-welcome', isWelcomeVM(element));
         templateData.rowContainer.classList.toggle('show-detail-progress', isResponseVM(element) && !element.isComplete && !element.progressMessages.length);
         templateData.username.textContent = element.username;
         if (!this.rendererOptions.noHeader) {
@@ -273,7 +278,7 @@ let ChatListItemRenderer = class ChatListItemRenderer extends Disposable {
             this.renderConfirmationAction(element, templateData);
         }
         if (isResponseVM(element) && index === this.delegate.getListLength() - 1 && (!element.isComplete || element.renderData) && element.response.value.length) {
-            this.traceLayout('renderElement', `start progressive render ${kind}, index=${index}`);
+            this.traceLayout('renderElement', `start progressive render, index=${index}`);
             const timer = templateData.elementDisposables.add(new WindowIntervalTimer());
             const runProgressiveRender = (initial) => {
                 try {
@@ -295,9 +300,6 @@ let ChatListItemRenderer = class ChatListItemRenderer extends Disposable {
         else if (isRequestVM(element)) {
             this.basicRenderElement(element, index, templateData);
         }
-        else {
-            this.renderWelcomeMessage(element, templateData);
-        }
     }
     renderDetail(element, templateData) {
         templateData.elementDisposables.add(autorun(reader => {
@@ -308,10 +310,10 @@ let ChatListItemRenderer = class ChatListItemRenderer extends Disposable {
         clearNode(templateData.detail);
         if (element.agentOrSlashCommandDetected) {
             const msg = element.slashCommand ? ( localize(
-                6997,
+                7212,
                 "used {0} [[(rerun without)]]",
                 `${chatSubcommandLeader}${element.slashCommand.name}`
-            )) : ( localize(6998, "[[(rerun without)]]"));
+            )) : ( localize(7213, "[[(rerun without)]]"));
             reset(templateData.detail, renderFormattedText(msg, {
                 className: 'agentOrSlashCommandDetected',
                 inline: true,
@@ -330,7 +332,7 @@ let ChatListItemRenderer = class ChatListItemRenderer extends Disposable {
     renderConfirmationAction(element, templateData) {
         clearNode(templateData.detail);
         if (element.confirmation) {
-            templateData.detail.textContent = ( localize(6999, 'selected "{0}"', element.confirmation));
+            templateData.detail.textContent = ( localize(7214, 'selected "{0}"', element.confirmation));
         }
     }
     renderAvatar(element, templateData) {
@@ -362,6 +364,7 @@ let ChatListItemRenderer = class ChatListItemRenderer extends Disposable {
         }
     }
     basicRenderElement(element, index, templateData) {
+        templateData.rowContainer.classList.toggle('chat-response-loading', isResponseVM(element) && !element.isComplete);
         let value = [];
         if (isRequestVM(element) && !element.confirmation) {
             const markdown = 'message' in element.message ?
@@ -388,7 +391,7 @@ let ChatListItemRenderer = class ChatListItemRenderer extends Disposable {
             value.forEach((data, index) => {
                 const context = {
                     element,
-                    index,
+                    contentIndex: index,
                     content: value,
                     preceedingContentParts: parts,
                 };
@@ -436,36 +439,6 @@ let ChatListItemRenderer = class ChatListItemRenderer extends Disposable {
         templateData.currentElement.currentRenderedHeight = newHeight;
         this._onDidChangeItemHeight.fire({ element: templateData.currentElement, height: newHeight });
     }
-    renderWelcomeMessage(element, templateData) {
-        clearNode(templateData.value);
-        element.content.forEach((item, i) => {
-            if (Array.isArray(item)) {
-                const scopedInstaService = templateData.elementDisposables.add(this.instantiationService.createChild(( (new ServiceCollection([IContextKeyService, templateData.contextKeyService])))));
-                templateData.elementDisposables.add(scopedInstaService.createInstance(ChatFollowups, templateData.value, item, this.location, undefined, followup => this._onDidClickFollowup.fire(followup)));
-            }
-            else {
-                const context = {
-                    element,
-                    index: i,
-                    content: [],
-                    preceedingContentParts: []
-                };
-                const result = this.renderMarkdown(item, templateData, context);
-                templateData.value.appendChild(result.domNode);
-                templateData.elementDisposables.add(result);
-            }
-        });
-        const newHeight = templateData.rowContainer.offsetHeight;
-        const fireEvent = !element.currentRenderedHeight || element.currentRenderedHeight !== newHeight;
-        element.currentRenderedHeight = newHeight;
-        if (fireEvent) {
-            const disposable = templateData.elementDisposables.add(scheduleAtNextAnimationFrame(getWindow(templateData.value), () => {
-                element.currentRenderedHeight = templateData.rowContainer.offsetHeight;
-                disposable.dispose();
-                this._onDidChangeItemHeight.fire({ element, height: element.currentRenderedHeight });
-            }));
-        }
-    }
     doNextProgressiveRender(element, index, templateData, isInRenderElement) {
         if (!this._isVisible) {
             return true;
@@ -476,6 +449,7 @@ let ChatListItemRenderer = class ChatListItemRenderer extends Disposable {
             this.basicRenderElement(element, index, templateData);
             return true;
         }
+        templateData.rowContainer.classList.toggle('chat-response-loading', true);
         let isFullyRendered = false;
         this.traceLayout('doNextProgressiveRender', `START progressive render, index=${index}, renderData=${JSON.stringify(element.renderData)}`);
         const contentForThisTurn = this.getNextProgressiveRenderContent(element);
@@ -489,7 +463,7 @@ let ChatListItemRenderer = class ChatListItemRenderer extends Disposable {
                 return true;
             }
             this.traceLayout('doNextProgressiveRender', 'caught up with the stream- no new content to render');
-            return false;
+            return true;
         }
         this.traceLayout('doNextProgressiveRender', `doing progressive render, ${partsToRender.length} parts to render`);
         this.renderChatContentDiff(partsToRender, contentForThisTurn, element, templateData);
@@ -516,7 +490,7 @@ let ChatListItemRenderer = class ChatListItemRenderer extends Disposable {
                 element,
                 content: contentForThisTurn,
                 preceedingContentParts,
-                index
+                contentIndex: index,
             };
             const newPart = this.renderChatContentPart(partToRender, templateData, context);
             if (newPart) {
@@ -633,6 +607,9 @@ let ChatListItemRenderer = class ChatListItemRenderer extends Disposable {
         else if (content.kind === 'codeCitations') {
             return this.renderCodeCitationsListData(content, context, templateData);
         }
+        else if (content.kind === 'toolInvocation' || content.kind === 'toolInvocationSerialized') {
+            return this.renderToolInvocation(content, context, templateData);
+        }
         return undefined;
     }
     renderTreeData(content, templateData, context) {
@@ -671,6 +648,13 @@ let ChatListItemRenderer = class ChatListItemRenderer extends Disposable {
         const citationsPart = this.instantiationService.createInstance(ChatCodeCitationContentPart, citations, context);
         return citationsPart;
     }
+    renderToolInvocation(toolInvocation, context, templateData) {
+        const part = this.instantiationService.createInstance(ChatToolInvocationPart, toolInvocation, context, this.renderer);
+        part.addDisposable(part.onDidChangeHeight(() => {
+            this.updateItemHeight(templateData);
+        }));
+        return part;
+    }
     renderProgressTask(task, templateData, context) {
         if (!isResponseVM(context.element)) {
             return;
@@ -702,6 +686,7 @@ let ChatListItemRenderer = class ChatListItemRenderer extends Disposable {
         const fillInIncompleteTokens = isResponseVM(element) && (!element.isComplete || element.isCanceled || element.errorDetails?.responseIsFiltered || element.errorDetails?.responseIsIncomplete || !!element.renderData);
         const codeBlockStartIndex = context.preceedingContentParts.reduce((acc, part) => acc + (part instanceof ChatMarkdownContentPart ? part.codeblocks.length : 0), 0);
         const markdownPart = this.instantiationService.createInstance(ChatMarkdownContentPart, markdown, context, this._editorPool, fillInIncompleteTokens, codeBlockStartIndex, this.renderer, this._currentLayoutWidth, this.codeBlockModelCollection, this.rendererOptions);
+        const markdownPartId = markdownPart.id;
         markdownPart.addDisposable(markdownPart.onDidChangeHeight(() => {
             markdownPart.layout(this._currentLayoutWidth);
             this.updateItemHeight(templateData);
@@ -711,7 +696,12 @@ let ChatListItemRenderer = class ChatListItemRenderer extends Disposable {
         markdownPart.addDisposable(toDisposable(() => {
             const codeBlocksByResponseId = this.codeBlocksByResponseId.get(element.id);
             if (codeBlocksByResponseId) {
-                markdownPart.codeblocks.forEach((info, i) => delete codeBlocksByResponseId[codeBlockStartIndex + i]);
+                markdownPart.codeblocks.forEach((info, i) => {
+                    const codeblock = codeBlocksByResponseId[codeBlockStartIndex + i];
+                    if (codeblock?.ownerMarkdownPartId === markdownPartId) {
+                        delete codeBlocksByResponseId[codeBlockStartIndex + i];
+                    }
+                });
             }
         }));
         markdownPart.codeblocks.forEach((info, i) => {
@@ -719,7 +709,12 @@ let ChatListItemRenderer = class ChatListItemRenderer extends Disposable {
             if (info.uri) {
                 const uri = info.uri;
                 this.codeBlocksByEditorUri.set(uri, info);
-                markdownPart.addDisposable(toDisposable(() => this.codeBlocksByEditorUri.delete(uri)));
+                markdownPart.addDisposable(toDisposable(() => {
+                    const codeblock = this.codeBlocksByEditorUri.get(uri);
+                    if (codeblock?.ownerMarkdownPartId === markdownPartId) {
+                        this.codeBlocksByEditorUri.delete(uri);
+                    }
+                }));
             }
         });
         return markdownPart;
@@ -744,13 +739,13 @@ let ChatListItemRenderer = class ChatListItemRenderer extends Disposable {
     }
 };
 ChatListItemRenderer = ChatListItemRenderer_1 = ( (__decorate([
-    ( (__param(6, IInstantiationService))),
-    ( (__param(7, IConfigurationService))),
-    ( (__param(8, ILogService))),
-    ( (__param(9, IContextKeyService))),
-    ( (__param(10, IThemeService))),
-    ( (__param(11, ICommandService))),
-    ( (__param(12, IHoverService)))
+    ( (__param(5, IInstantiationService))),
+    ( (__param(6, IConfigurationService))),
+    ( (__param(7, ILogService))),
+    ( (__param(8, IContextKeyService))),
+    ( (__param(9, IThemeService))),
+    ( (__param(10, ICommandService))),
+    ( (__param(11, IHoverService)))
 ], ChatListItemRenderer)));
 let ChatListDelegate = class ChatListDelegate {
     constructor(defaultElementHeight, logService) {
@@ -779,15 +774,15 @@ ChatListDelegate = ( (__decorate([
     ( (__param(1, ILogService)))
 ], ChatListDelegate)));
 const voteDownDetailLabels = {
-    [ChatAgentVoteDownReason.IncorrectCode]: ( localize(7000, "Suggested incorrect code")),
-    [ChatAgentVoteDownReason.DidNotFollowInstructions]: ( localize(7001, "Didn't follow instructions")),
-    [ChatAgentVoteDownReason.MissingContext]: ( localize(7002, "Missing context")),
-    [ChatAgentVoteDownReason.OffensiveOrUnsafe]: ( localize(7003, "Offensive or unsafe")),
-    [ChatAgentVoteDownReason.PoorlyWrittenOrFormatted]: ( localize(7004, "Poorly written or formatted")),
-    [ChatAgentVoteDownReason.RefusedAValidRequest]: ( localize(7005, "Refused a valid request")),
-    [ChatAgentVoteDownReason.IncompleteCode]: ( localize(7006, "Incomplete code")),
-    [ChatAgentVoteDownReason.WillReportIssue]: ( localize(7007, "Report an issue")),
-    [ChatAgentVoteDownReason.Other]: ( localize(7008, "Other")),
+    [ChatAgentVoteDownReason.IncorrectCode]: ( localize(7215, "Suggested incorrect code")),
+    [ChatAgentVoteDownReason.DidNotFollowInstructions]: ( localize(7216, "Didn't follow instructions")),
+    [ChatAgentVoteDownReason.MissingContext]: ( localize(7217, "Missing context")),
+    [ChatAgentVoteDownReason.OffensiveOrUnsafe]: ( localize(7218, "Offensive or unsafe")),
+    [ChatAgentVoteDownReason.PoorlyWrittenOrFormatted]: ( localize(7219, "Poorly written or formatted")),
+    [ChatAgentVoteDownReason.RefusedAValidRequest]: ( localize(7220, "Refused a valid request")),
+    [ChatAgentVoteDownReason.IncompleteCode]: ( localize(7221, "Incomplete code")),
+    [ChatAgentVoteDownReason.WillReportIssue]: ( localize(7222, "Report an issue")),
+    [ChatAgentVoteDownReason.Other]: ( localize(7223, "Other")),
 };
 let ChatVoteDownButton = class ChatVoteDownButton extends DropdownMenuActionViewItem {
     constructor(action, options, commandService, issueService, logService, contextMenuService) {

package/vscode/src/vs/workbench/contrib/chat/browser/chatMarkdownDecorationsRenderer.js

@@ -4,7 +4,7 @@ import { Button } from '../../../../base/browser/ui/button/button.js';
 import { getDefaultHoverDelegate } from '../../../../base/browser/ui/hover/hoverDelegateFactory.js';
 import { toErrorMessage } from '../../../../base/common/errorMessage.js';
 import { Lazy } from '../../../../base/common/lazy.js';
-import { DisposableStore } from '../../../../base/common/lifecycle.js';
+import { Disposable, DisposableStore } from '../../../../base/common/lifecycle.js';
 import { revive } from '../../../../base/common/marshalling.js';
 import { URI } from '../../../../base/common/uri.js';
 import { ICommandService } from '../../../../platform/commands/common/commands.service.js';
@@ -14,16 +14,18 @@ import { IKeybindingService } from '../../../../platform/keybinding/common/keybi
 import { ILabelService } from '../../../../platform/label/common/label.service.js';
 import { ILogService } from '../../../../platform/log/common/log.service.js';
 import { asCssVariable } from '../../../../platform/theme/common/colorUtils.js';
-import { IChatWidgetService } from './chat.service.js';
-import { getChatAgentHoverOptions, ChatAgentHover } from './chatAgentHover.js';
+import { contentRefUrl } from '../common/annotations.js';
 import { getFullyQualifiedId } from '../common/chatAgents.js';
 import { IChatAgentNameService, IChatAgentService } from '../common/chatAgents.service.js';
 import { chatSlashCommandBackground, chatSlashCommandForeground } from '../common/chatColors.js';
 import { ChatRequestTextPart, ChatRequestAgentPart, ChatRequestSlashCommandPart, ChatRequestAgentSubcommandPart, ChatRequestVariablePart, ChatRequestToolPart, ChatRequestDynamicVariablePart, chatAgentLeader, chatSubcommandLeader } from '../common/chatParserTypes.js';
 import { IChatService } from '../common/chatService.service.js';
-import { contentRefUrl } from '../common/annotations.js';
 import { IChatVariablesService } from '../common/chatVariables.service.js';
 import { ILanguageModelToolsService } from '../common/languageModelToolsService.service.js';
+import { IChatWidgetService } from './chat.service.js';
+import { getChatAgentHoverOptions, ChatAgentHover } from './chatAgentHover.js';
+import { InlineAnchorWidget } from './chatInlineAnchorWidget.js';
+import './media/chatInlineAnchorWidget.css.js';
 const decorationRefUrl = `http://_vscodedecoration_`;
 const agentRefUrl = `http://_chatagent_`;
 const agentSlashRefUrl = `http://_chatslash_`;
@@ -44,10 +46,10 @@ function agentSlashCommandToMarkdown(agent, command) {
     const args = { agentId: agent.id, command: command.name };
     return `[${text}](${agentSlashRefUrl}?${encodeURIComponent(JSON.stringify(args))})`;
 }
-let ChatMarkdownDecorationsRenderer = class ChatMarkdownDecorationsRenderer {
-    constructor(keybindingService, labelService, logService, chatAgentService, instantiationService, hoverService, chatService, chatWidgetService, commandService, chatVariablesService, toolsService) {
+let ChatMarkdownDecorationsRenderer = class ChatMarkdownDecorationsRenderer extends Disposable {
+    constructor(keybindingService, logService, chatAgentService, instantiationService, hoverService, chatService, chatWidgetService, commandService, chatVariablesService, labelService, toolsService) {
+        super();
         this.keybindingService = keybindingService;
-        this.labelService = labelService;
         this.logService = logService;
         this.chatAgentService = chatAgentService;
         this.instantiationService = instantiationService;
@@ -56,6 +58,7 @@ let ChatMarkdownDecorationsRenderer = class ChatMarkdownDecorationsRenderer {
         this.chatWidgetService = chatWidgetService;
         this.commandService = commandService;
         this.chatVariablesService = chatVariablesService;
+        this.labelService = labelService;
         this.toolsService = toolsService;
     }
     convertParsedRequestToMarkdown(parsedRequest) {
@@ -125,7 +128,7 @@ let ChatMarkdownDecorationsRenderer = class ChatMarkdownDecorationsRenderer {
                     a.parentElement.replaceChild(this.renderResourceWidget(a.textContent, args, store), a);
                 }
                 else if (href.startsWith(contentRefUrl)) {
-                    this.renderFileWidget(href, a);
+                    this.renderFileWidget(href, a, store);
                 }
                 else if (href.startsWith('command:')) {
                     this.injectKeybindingHint(a, href, this.keybindingService);
@@ -184,26 +187,21 @@ let ChatMarkdownDecorationsRenderer = class ChatMarkdownDecorationsRenderer {
         }));
         return container;
     }
-    renderFileWidget(href, a) {
+    renderFileWidget(href, a, store) {
         const fullUri = ( URI.parse(href));
-        let location;
+        let data;
         try {
-            location = revive(JSON.parse(fullUri.fragment));
+            data = revive(JSON.parse(fullUri.fragment));
         }
         catch (err) {
             this.logService.error('Invalid chat widget render data JSON', toErrorMessage(err));
             return;
         }
-        if (!location.uri || !URI.isUri(location.uri)) {
+        if (data.kind !== 'symbol' && !URI.isUri(data.uri)) {
             this.logService.error(`Invalid chat widget render data: ${fullUri.fragment}`);
             return;
         }
-        const fragment = location.range ? `${location.range.startLineNumber}-${location.range.endLineNumber}` : '';
-        a.setAttribute('data-href', ( location.uri.with({ fragment }).toString()));
-        const label = this.labelService.getUriLabel(location.uri, { relative: true });
-        a.title = location.range ?
-            `${label}#${location.range.startLineNumber}-${location.range.endLineNumber}` :
-            label;
+        store.add(this.instantiationService.createInstance(InlineAnchorWidget, a, data));
     }
     renderResourceWidget(name, args, store) {
         const container = $('span.chat-resource-widget');
@@ -229,15 +227,15 @@ let ChatMarkdownDecorationsRenderer = class ChatMarkdownDecorationsRenderer {
 };
 ChatMarkdownDecorationsRenderer = ( __decorate([
     ( __param(0, IKeybindingService)),
-    ( __param(1, ILabelService)),
-    ( __param(2, ILogService)),
-    ( __param(3, IChatAgentService)),
-    ( __param(4, IInstantiationService)),
-    ( __param(5, IHoverService)),
-    ( __param(6, IChatService)),
-    ( __param(7, IChatWidgetService)),
-    ( __param(8, ICommandService)),
-    ( __param(9, IChatVariablesService)),
+    ( __param(1, ILogService)),
+    ( __param(2, IChatAgentService)),
+    ( __param(3, IInstantiationService)),
+    ( __param(4, IHoverService)),
+    ( __param(5, IChatService)),
+    ( __param(6, IChatWidgetService)),
+    ( __param(7, ICommandService)),
+    ( __param(8, IChatVariablesService)),
+    ( __param(9, ILabelService)),
     ( __param(10, ILanguageModelToolsService))
 ], ChatMarkdownDecorationsRenderer));
 export { ChatMarkdownDecorationsRenderer, agentSlashCommandToMarkdown, agentToMarkdown };

package/vscode/src/vs/workbench/contrib/chat/browser/chatMarkdownRenderer.js

@@ -1,10 +1,14 @@
 import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
 import { getDefaultHoverDelegate } from '../../../../base/browser/ui/hover/hoverDelegateFactory.js';
 import { DisposableStore } from '../../../../base/common/lifecycle.js';
+import { URI } from '../../../../base/common/uri.js';
 import { MarkdownRenderer } from '../../../../editor/browser/widget/markdownRenderer/browser/markdownRenderer.js';
 import { ILanguageService } from '../../../../editor/common/languages/language.js';
+import { ICommandService } from '../../../../platform/commands/common/commands.service.js';
+import { IFileService } from '../../../../platform/files/common/files.service.js';
 import { IHoverService } from '../../../../platform/hover/browser/hover.service.js';
 import { IOpenerService } from '../../../../platform/opener/common/opener.service.js';
+import { REVEAL_IN_EXPLORER_COMMAND_ID } from '../../files/browser/fileConstants.js';
 import { ITrustedDomainService } from '../../url/browser/trustedDomainService.service.js';
 const allowedHtmlTags = [
     'b',
@@ -40,10 +44,12 @@ const allowedHtmlTags = [
     'div',
 ];
 let ChatMarkdownRenderer = class ChatMarkdownRenderer extends MarkdownRenderer {
-    constructor(options, languageService, openerService, trustedDomainService, hoverService) {
+    constructor(options, languageService, openerService, trustedDomainService, hoverService, fileService, commandService) {
         super(options ?? {}, languageService, openerService);
         this.trustedDomainService = trustedDomainService;
         this.hoverService = hoverService;
+        this.fileService = fileService;
+        this.commandService = commandService;
     }
     render(markdown, options, markedOptions) {
         options = {
@@ -80,11 +86,24 @@ let ChatMarkdownRenderer = class ChatMarkdownRenderer extends MarkdownRenderer {
             }
         };
     }
+    async openMarkdownLink(link, markdown) {
+        try {
+            const uri = ( URI.parse(link));
+            if ((await this.fileService.stat(uri)).isDirectory) {
+                return this.commandService.executeCommand(REVEAL_IN_EXPLORER_COMMAND_ID, uri);
+            }
+        }
+        catch {
+        }
+        return super.openMarkdownLink(link, markdown);
+    }
 };
 ChatMarkdownRenderer = ( __decorate([
     ( __param(1, ILanguageService)),
     ( __param(2, IOpenerService)),
     ( __param(3, ITrustedDomainService)),
-    ( __param(4, IHoverService))
+    ( __param(4, IHoverService)),
+    ( __param(5, IFileService)),
+    ( __param(6, ICommandService))
 ], ChatMarkdownRenderer));
 export { ChatMarkdownRenderer };