@codingame/monaco-vscode-katex-common 24.1.0

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

@@ -0,0 +1,951 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { append, $, addDisposableListener, EventType, addStandardDisposableListener, EventHelper, getWindow } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { StandardKeyboardEvent } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/keyboardEvent';
+import { StandardMouseEvent } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/mouseEvent';
+import { Button } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/button/button';
+import { HoverStyle } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/hover/hover';
+import { createInstantHoverDelegate } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/hover/hoverDelegateFactory';
+import { HoverPosition } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/hover/hoverWidget';
+import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
+import { Emitter, Event } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { MarkdownString } from '@codingame/monaco-vscode-api/vscode/vs/base/common/htmlContent';
+import { Iterable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/iterator';
+import { KeyCode } from '@codingame/monaco-vscode-api/vscode/vs/base/common/keyCodes';
+import { Disposable, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { Schemas } from '@codingame/monaco-vscode-api/vscode/vs/base/common/network';
+import { basename, dirname } from '@codingame/monaco-vscode-api/vscode/vs/base/common/path';
+import { ThemeIcon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/themables';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { EditorContextKeys } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/editorContextKeys';
+import { ILanguageService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/languages/language.service';
+import { ILanguageFeaturesService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/languageFeatures.service';
+import { IModelService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/model.service';
+import { ITextModelService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/resolverService.service';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { getFlatContextMenuActions } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/browser/menuEntryActionViewItem';
+import { MenuId } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions';
+import { IMenuService } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions.service';
+import { ICommandService } from '@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands.service';
+import { RawContextKey } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey';
+import { IContextKeyService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service';
+import { IContextMenuService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextview/browser/contextView.service';
+import { fillInSymbolsDragData } from '@codingame/monaco-vscode-api/vscode/vs/platform/dnd/browser/dnd';
+import { registerOpenEditorListeners } from '../../../../platform/editor/browser/editor.js';
+import { FileKind } from '@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files';
+import { IFileService } from '@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service';
+import { IHoverService } from '@codingame/monaco-vscode-api/vscode/vs/platform/hover/browser/hover.service';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { ILabelService } from '@codingame/monaco-vscode-api/vscode/vs/platform/label/common/label.service';
+import { IMarkdownRendererService } from '@codingame/monaco-vscode-api/vscode/vs/platform/markdown/browser/markdownRenderer.service';
+import { IOpenerService } from '@codingame/monaco-vscode-api/vscode/vs/platform/opener/common/opener.service';
+import { FolderThemeIcon } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/themeService';
+import { IThemeService } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/themeService.service';
+import { fillEditorsDragData } from '@codingame/monaco-vscode-api/vscode/vs/workbench/browser/dnd';
+import { ResourceContextKey } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/contextkeys';
+import { SIDE_GROUP } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService';
+import { IEditorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service';
+import { IPreferencesService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/preferences/common/preferences.service';
+import { revealInSideBarCommand } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/files/browser/fileActions.contribution';
+import { CellUri } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookCommon';
+import { INotebookService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookService.service';
+import { toHistoryItemHoverContent } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/scm/browser/scmHistory';
+import { getHistoryItemEditorTitle } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/scm/browser/util';
+import { ITerminalService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/terminal.service';
+import { OmittedState, PromptFileVariableKind } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatVariableEntries';
+import { ILanguageModelsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModels.service';
+import { ToolSet } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModelToolsService';
+import { ILanguageModelToolsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModelToolsService.service';
+import { getCleanPromptName } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/config/promptFileLocations';
+
+const commonHoverOptions = {
+    style: HoverStyle.Pointer,
+    position: {
+        hoverPosition: HoverPosition.BELOW
+    },
+    trapFocus: true,
+};
+const commonHoverLifecycleOptions = {
+    groupId: 'chat-attachments',
+};
+let AbstractChatAttachmentWidget = class AbstractChatAttachmentWidget extends Disposable {
+    get onDidDelete() {
+        return this._onDidDelete.event;
+    }
+    get onDidOpen() {
+        return this._onDidOpen.event;
+    }
+    constructor(attachment, options, container, contextResourceLabels, currentLanguageModel, commandService, openerService, terminalService) {
+        super();
+        this.attachment = attachment;
+        this.options = options;
+        this.currentLanguageModel = currentLanguageModel;
+        this.commandService = commandService;
+        this.openerService = openerService;
+        this.terminalService = terminalService;
+        this._onDidDelete = this._register(new Emitter());
+        this._onDidOpen = this._register(new Emitter());
+        this.element = append(container, $('.chat-attached-context-attachment.show-file-icons'));
+        this.label = contextResourceLabels.create(this.element, { supportIcons: true, hoverTargetOverride: this.element });
+        this._register(this.label);
+        this.element.tabIndex = 0;
+        this.element.role = 'button';
+        this._register(addDisposableListener(this.element, EventType.AUXCLICK, (e) => {
+            if (e.button === 1  && this.options.supportsDeletion && !this.attachment.range) {
+                e.preventDefault();
+                e.stopPropagation();
+                this._onDidDelete.fire(e);
+            }
+        }));
+    }
+    modelSupportsVision() {
+        return modelSupportsVision(this.currentLanguageModel);
+    }
+    attachClearButton() {
+        if (this.attachment.range || !this.options.supportsDeletion) {
+            return;
+        }
+        const clearButton = ( new Button(this.element, {
+            supportIcons: true,
+            hoverDelegate: createInstantHoverDelegate(),
+            title: ( localize(5013, "Remove from context"))
+        }));
+        clearButton.element.tabIndex = -1;
+        clearButton.icon = Codicon.close;
+        this._register(clearButton);
+        this._register(Event.once(clearButton.onDidClick)((e) => {
+            this._onDidDelete.fire(e);
+        }));
+        this._register(addStandardDisposableListener(this.element, EventType.KEY_DOWN, e => {
+            if (e.keyCode === KeyCode.Backspace || e.keyCode === KeyCode.Delete) {
+                this._onDidDelete.fire(e.browserEvent);
+            }
+        }));
+    }
+    addResourceOpenHandlers(resource, range) {
+        this.element.style.cursor = 'pointer';
+        this._register(registerOpenEditorListeners(this.element, async (options) => {
+            if (this.attachment.kind === 'directory') {
+                await this.openResource(resource, options, true);
+            }
+            else {
+                await this.openResource(resource, options, false, range);
+            }
+        }));
+    }
+    async openResource(resource, openOptions, isDirectory, range) {
+        if (isDirectory) {
+            this.commandService.executeCommand(revealInSideBarCommand.id, resource);
+            return;
+        }
+        if (resource.scheme === Schemas.vscodeTerminal) {
+            this.terminalService?.openResource(resource);
+            return;
+        }
+        const openTextEditorOptions = range ? { selection: range } : undefined;
+        const options = {
+            fromUserGesture: true,
+            openToSide: openOptions.openToSide,
+            editorOptions: {
+                ...openTextEditorOptions,
+                ...openOptions.editorOptions
+            },
+        };
+        await this.openerService.open(resource, options);
+        this._onDidOpen.fire();
+        this.element.focus();
+    }
+};
+AbstractChatAttachmentWidget = ( __decorate([
+    ( __param(5, ICommandService)),
+    ( __param(6, IOpenerService)),
+    ( __param(7, ITerminalService))
+], AbstractChatAttachmentWidget));
+function modelSupportsVision(currentLanguageModel) {
+    return currentLanguageModel?.metadata.capabilities?.vision ?? false;
+}
+let FileAttachmentWidget = class FileAttachmentWidget extends AbstractChatAttachmentWidget {
+    constructor(resource, range, attachment, correspondingContentReference, currentLanguageModel, options, container, contextResourceLabels, commandService, openerService, themeService, hoverService, languageModelsService, instantiationService) {
+        super(attachment, options, container, contextResourceLabels, currentLanguageModel, commandService, openerService);
+        this.themeService = themeService;
+        this.hoverService = hoverService;
+        this.languageModelsService = languageModelsService;
+        this.instantiationService = instantiationService;
+        const fileBasename = basename(resource.path);
+        const fileDirname = dirname(resource.path);
+        const friendlyName = `${fileBasename} ${fileDirname}`;
+        let ariaLabel = range ? ( localize(
+            5014,
+            "Attached file, {0}, line {1} to line {2}",
+            friendlyName,
+            range.startLineNumber,
+            range.endLineNumber
+        )) : ( localize(5015, "Attached file, {0}", friendlyName));
+        if (attachment.omittedState === OmittedState.Full) {
+            ariaLabel = ( localize(5016, "Omitted this file: {0}", attachment.name));
+            this.renderOmittedWarning(friendlyName, ariaLabel);
+        }
+        else {
+            const fileOptions = { hidePath: true, title: correspondingContentReference?.options?.status?.description };
+            this.label.setFile(resource, attachment.kind === 'file' ? {
+                ...fileOptions,
+                fileKind: FileKind.FILE,
+                range,
+            } : {
+                ...fileOptions,
+                fileKind: FileKind.FOLDER,
+                icon: !this.themeService.getFileIconTheme().hasFolderIcons ? FolderThemeIcon : undefined
+            });
+        }
+        this.element.ariaLabel = ariaLabel;
+        this.instantiationService.invokeFunction(accessor => {
+            this._register(hookUpResourceAttachmentDragAndContextMenu(accessor, this.element, resource));
+        });
+        this.addResourceOpenHandlers(resource, range);
+        this.attachClearButton();
+    }
+    renderOmittedWarning(friendlyName, ariaLabel) {
+        const pillIcon = $('div.chat-attached-context-pill', {}, $('span.codicon.codicon-warning'));
+        const textLabel = $('span.chat-attached-context-custom-text', {}, friendlyName);
+        this.element.appendChild(pillIcon);
+        this.element.appendChild(textLabel);
+        const hoverElement = $('div.chat-attached-context-hover');
+        hoverElement.setAttribute('aria-label', ariaLabel);
+        this.element.classList.add('warning');
+        hoverElement.textContent = ( localize(
+            5017,
+            "{0} does not support this file type.",
+            this.currentLanguageModel ? this.languageModelsService.lookupLanguageModel(this.currentLanguageModel.identifier)?.name : this.currentLanguageModel ?? 'This model'
+        ));
+        this._register(this.hoverService.setupDelayedHover(this.element, {
+            ...commonHoverOptions,
+            content: hoverElement,
+        }, commonHoverLifecycleOptions));
+    }
+};
+FileAttachmentWidget = ( __decorate([
+    ( __param(8, ICommandService)),
+    ( __param(9, IOpenerService)),
+    ( __param(10, IThemeService)),
+    ( __param(11, IHoverService)),
+    ( __param(12, ILanguageModelsService)),
+    ( __param(13, IInstantiationService))
+], FileAttachmentWidget));
+let TerminalCommandAttachmentWidget = class TerminalCommandAttachmentWidget extends AbstractChatAttachmentWidget {
+    constructor(attachment, currentLanguageModel, options, container, contextResourceLabels, commandService, openerService, hoverService, terminalService) {
+        super(attachment, options, container, contextResourceLabels, currentLanguageModel, commandService, openerService, terminalService);
+        this.hoverService = hoverService;
+        this.terminalService = terminalService;
+        const ariaLabel = ( localize(5018, "Terminal command, {0}", attachment.command));
+        const clickHandler = () => this.openResource(attachment.resource, { editorOptions: { preserveFocus: true } }, false, undefined);
+        this._register(createTerminalCommandElements(this.element, attachment, ariaLabel, this.hoverService, clickHandler));
+        this._register(addDisposableListener(this.element, EventType.KEY_DOWN, async (e) => {
+            const event = ( new StandardKeyboardEvent(e));
+            if (event.equals(KeyCode.Enter) || event.equals(KeyCode.Space)) {
+                EventHelper.stop(e, true);
+                await clickHandler();
+            }
+        }));
+        this.attachClearButton();
+    }
+};
+TerminalCommandAttachmentWidget = ( __decorate([
+    ( __param(5, ICommandService)),
+    ( __param(6, IOpenerService)),
+    ( __param(7, IHoverService)),
+    ( __param(8, ITerminalService))
+], TerminalCommandAttachmentWidget));
+var TerminalConstants;
+(function (TerminalConstants) {
+    TerminalConstants[TerminalConstants["MaxAttachmentOutputLineCount"] = 5] = "MaxAttachmentOutputLineCount";
+    TerminalConstants[TerminalConstants["MaxAttachmentOutputLineLength"] = 80] = "MaxAttachmentOutputLineLength";
+})(TerminalConstants || (TerminalConstants = {}));
+function createTerminalCommandElements(element, attachment, ariaLabel, hoverService, clickHandler) {
+    const disposable = ( new DisposableStore());
+    element.ariaLabel = ariaLabel;
+    element.style.cursor = 'pointer';
+    const terminalIconSpan = $('span');
+    terminalIconSpan.classList.add(...ThemeIcon.asClassNameArray(Codicon.terminal));
+    const pillIcon = $('div.chat-attached-context-pill', {}, terminalIconSpan);
+    const textLabel = $('span.chat-attached-context-custom-text', {}, attachment.command);
+    element.appendChild(pillIcon);
+    element.appendChild(textLabel);
+    disposable.add(addDisposableListener(element, EventType.CLICK, e => {
+        e.preventDefault();
+        e.stopPropagation();
+        clickHandler();
+    }));
+    const hoverElement = $('div.chat-attached-context-hover');
+    hoverElement.setAttribute('aria-label', ariaLabel);
+    const commandTitle = $('div', {}, typeof attachment.exitCode === 'number'
+        ? ( localize(
+        5019,
+        "Command: {0}, exit code: {1}",
+        attachment.command,
+        attachment.exitCode
+    ))
+        : ( localize(5020, "Command")));
+    commandTitle.classList.add('attachment-additional-info');
+    const commandBlock = $('pre.chat-terminal-command-block');
+    hoverElement.append(commandTitle, commandBlock);
+    if (attachment.output && attachment.output.trim().length > 0) {
+        const outputTitle = $('div', {}, ( localize(5021, "Output:")));
+        outputTitle.classList.add('attachment-additional-info');
+        const outputBlock = $('pre.chat-terminal-command-output');
+        const fullOutputLines = attachment.output.split('\n');
+        const hoverOutputLines = [];
+        for (const line of fullOutputLines) {
+            if (hoverOutputLines.length >= TerminalConstants.MaxAttachmentOutputLineCount) {
+                hoverOutputLines.push('...');
+                break;
+            }
+            const trimmed = line.trim();
+            if (trimmed.length === 0) {
+                continue;
+            }
+            if (trimmed.length > TerminalConstants.MaxAttachmentOutputLineLength) {
+                hoverOutputLines.push(`${trimmed.slice(0, TerminalConstants.MaxAttachmentOutputLineLength)}...`);
+            }
+            else {
+                hoverOutputLines.push(trimmed);
+            }
+        }
+        outputBlock.textContent = hoverOutputLines.join('\n');
+        hoverElement.append(outputTitle, outputBlock);
+    }
+    const hint = $('div', {}, ( localize(5022, "Click to focus this command in the terminal.")));
+    hint.classList.add('attachment-additional-info');
+    hoverElement.appendChild(hint);
+    disposable.add(hoverService.setupDelayedHover(element, {
+        ...commonHoverOptions,
+        content: hoverElement,
+    }, commonHoverLifecycleOptions));
+    return disposable;
+}
+let ImageAttachmentWidget = class ImageAttachmentWidget extends AbstractChatAttachmentWidget {
+    constructor(resource, attachment, currentLanguageModel, options, container, contextResourceLabels, commandService, openerService, hoverService, languageModelsService, instantiationService, labelService) {
+        super(attachment, options, container, contextResourceLabels, currentLanguageModel, commandService, openerService);
+        this.hoverService = hoverService;
+        this.languageModelsService = languageModelsService;
+        this.labelService = labelService;
+        let ariaLabel;
+        if (attachment.omittedState === OmittedState.Full) {
+            ariaLabel = ( localize(5023, "Omitted this image: {0}", attachment.name));
+        }
+        else if (attachment.omittedState === OmittedState.Partial) {
+            ariaLabel = ( localize(5024, "Partially omitted this image: {0}", attachment.name));
+        }
+        else {
+            ariaLabel = ( localize(5025, "Attached image, {0}", attachment.name));
+        }
+        const ref = attachment.references?.[0]?.reference;
+        resource = ref && URI.isUri(ref) ? ref : undefined;
+        const clickHandler = async () => {
+            if (resource) {
+                await this.openResource(resource, { editorOptions: { preserveFocus: true } }, false, undefined);
+            }
+        };
+        const currentLanguageModelName = this.currentLanguageModel ? this.languageModelsService.lookupLanguageModel(this.currentLanguageModel.identifier)?.name ?? this.currentLanguageModel.identifier : 'Current model';
+        const fullName = resource ? this.labelService.getUriLabel(resource) : (attachment.fullName || attachment.name);
+        this._register(createImageElements(resource, attachment.name, fullName, this.element, attachment.value, this.hoverService, ariaLabel, currentLanguageModelName, clickHandler, this.currentLanguageModel, attachment.omittedState));
+        if (resource) {
+            this.addResourceOpenHandlers(resource, undefined);
+            instantiationService.invokeFunction(accessor => {
+                this._register(hookUpResourceAttachmentDragAndContextMenu(accessor, this.element, resource));
+            });
+        }
+        this.attachClearButton();
+    }
+};
+ImageAttachmentWidget = ( __decorate([
+    ( __param(6, ICommandService)),
+    ( __param(7, IOpenerService)),
+    ( __param(8, IHoverService)),
+    ( __param(9, ILanguageModelsService)),
+    ( __param(10, IInstantiationService)),
+    ( __param(11, ILabelService))
+], ImageAttachmentWidget));
+function createImageElements(resource, name, fullName, element, buffer, hoverService, ariaLabel, currentLanguageModelName, clickHandler, currentLanguageModel, omittedState) {
+    const disposable = ( new DisposableStore());
+    if (omittedState === OmittedState.Partial) {
+        element.classList.add('partial-warning');
+    }
+    element.ariaLabel = ariaLabel;
+    element.style.position = 'relative';
+    if (resource) {
+        element.style.cursor = 'pointer';
+        disposable.add(addDisposableListener(element, 'click', clickHandler));
+    }
+    const supportsVision = modelSupportsVision(currentLanguageModel);
+    const pillIcon = $('div.chat-attached-context-pill', {}, $(supportsVision ? 'span.codicon.codicon-file-media' : 'span.codicon.codicon-warning'));
+    const textLabel = $('span.chat-attached-context-custom-text', {}, name);
+    element.appendChild(pillIcon);
+    element.appendChild(textLabel);
+    const hoverElement = $('div.chat-attached-context-hover');
+    hoverElement.setAttribute('aria-label', ariaLabel);
+    if ((!supportsVision && currentLanguageModel) || omittedState === OmittedState.Full) {
+        element.classList.add('warning');
+        hoverElement.textContent = ( localize(
+            5026,
+            "{0} does not support images.",
+            currentLanguageModelName ?? 'This model'
+        ));
+        disposable.add(hoverService.setupDelayedHover(element, {
+            content: hoverElement,
+            style: HoverStyle.Pointer,
+        }));
+    }
+    else {
+        disposable.add(hoverService.setupDelayedHover(element, {
+            content: hoverElement,
+            style: HoverStyle.Pointer,
+        }));
+        const blob = ( new Blob([buffer], { type: 'image/png' }));
+        const url = URL.createObjectURL(blob);
+        const pillImg = $('img.chat-attached-context-pill-image', { src: url, alt: '' });
+        const pill = $('div.chat-attached-context-pill', {}, pillImg);
+        const existingPill = element.querySelector('.chat-attached-context-pill');
+        if (existingPill) {
+            existingPill.replaceWith(pill);
+        }
+        const hoverImage = $('img.chat-attached-context-image', { src: url, alt: '' });
+        const imageContainer = $('div.chat-attached-context-image-container', {}, hoverImage);
+        hoverElement.appendChild(imageContainer);
+        if (resource) {
+            const urlContainer = $('a.chat-attached-context-url', {}, omittedState === OmittedState.Partial ? ( localize(5027, "This GIF was partially omitted - current frame will be sent.")) : fullName);
+            const separator = $('div.chat-attached-context-url-separator');
+            disposable.add(addDisposableListener(urlContainer, 'click', () => clickHandler()));
+            hoverElement.append(separator, urlContainer);
+        }
+        hoverImage.onload = () => { URL.revokeObjectURL(url); };
+        hoverImage.onerror = () => {
+            const pillIcon = $('div.chat-attached-context-pill', {}, $('span.codicon.codicon-file-media'));
+            const pill = $('div.chat-attached-context-pill', {}, pillIcon);
+            const existingPill = element.querySelector('.chat-attached-context-pill');
+            if (existingPill) {
+                existingPill.replaceWith(pill);
+            }
+        };
+    }
+    return disposable;
+}
+let PasteAttachmentWidget = class PasteAttachmentWidget extends AbstractChatAttachmentWidget {
+    constructor(attachment, currentLanguageModel, options, container, contextResourceLabels, commandService, openerService, hoverService, instantiationService) {
+        super(attachment, options, container, contextResourceLabels, currentLanguageModel, commandService, openerService);
+        this.hoverService = hoverService;
+        this.instantiationService = instantiationService;
+        const ariaLabel = ( localize(5028, "Attached context, {0}", attachment.name));
+        this.element.ariaLabel = ariaLabel;
+        const classNames = ['file-icon', `${attachment.language}-lang-file-icon`];
+        let resource;
+        let range;
+        if (attachment.copiedFrom) {
+            resource = attachment.copiedFrom.uri;
+            range = attachment.copiedFrom.range;
+            const filename = basename(resource.path);
+            this.label.setLabel(filename, undefined, { extraClasses: classNames });
+        }
+        else {
+            this.label.setLabel(attachment.fileName, undefined, { extraClasses: classNames });
+        }
+        this.element.appendChild($('span.attachment-additional-info', {}, `Pasted ${attachment.pastedLines}`));
+        this.element.style.position = 'relative';
+        const sourceUri = attachment.copiedFrom?.uri;
+        const hoverContent = ( new MarkdownString(
+            `${sourceUri ? this.instantiationService.invokeFunction(accessor => accessor.get(ILabelService).getUriLabel(sourceUri, { relative: true })) : attachment.fileName}\n\n---\n\n\`\`\`${attachment.language}\n\n${attachment.code}\n\`\`\``
+        ));
+        this._register(this.hoverService.setupDelayedHover(this.element, {
+            ...commonHoverOptions,
+            content: hoverContent,
+        }, commonHoverLifecycleOptions));
+        const copiedFromResource = attachment.copiedFrom?.uri;
+        if (copiedFromResource) {
+            this._register(this.instantiationService.invokeFunction(hookUpResourceAttachmentDragAndContextMenu, this.element, copiedFromResource));
+            this.addResourceOpenHandlers(copiedFromResource, range);
+        }
+        this.attachClearButton();
+    }
+};
+PasteAttachmentWidget = ( __decorate([
+    ( __param(5, ICommandService)),
+    ( __param(6, IOpenerService)),
+    ( __param(7, IHoverService)),
+    ( __param(8, IInstantiationService))
+], PasteAttachmentWidget));
+let DefaultChatAttachmentWidget = class DefaultChatAttachmentWidget extends AbstractChatAttachmentWidget {
+    constructor(resource, range, attachment, correspondingContentReference, currentLanguageModel, options, container, contextResourceLabels, commandService, openerService, contextKeyService, instantiationService) {
+        super(attachment, options, container, contextResourceLabels, currentLanguageModel, commandService, openerService);
+        this.contextKeyService = contextKeyService;
+        this.instantiationService = instantiationService;
+        const attachmentLabel = attachment.fullName ?? attachment.name;
+        const withIcon = attachment.icon?.id ? `$(${attachment.icon.id})\u00A0${attachmentLabel}` : attachmentLabel;
+        this.label.setLabel(withIcon, correspondingContentReference?.options?.status?.description);
+        this.element.ariaLabel = ( localize(5028, "Attached context, {0}", attachment.name));
+        if (attachment.kind === 'diagnostic') {
+            if (attachment.filterUri) {
+                resource = attachment.filterUri ? URI.revive(attachment.filterUri) : undefined;
+                range = attachment.filterRange;
+            }
+            else {
+                this.element.style.cursor = 'pointer';
+                this._register(addDisposableListener(this.element, EventType.CLICK, () => {
+                    this.commandService.executeCommand('workbench.panel.markers.view.focus');
+                }));
+            }
+        }
+        if (attachment.kind === 'symbol') {
+            const scopedContextKeyService = this._register(this.contextKeyService.createScoped(this.element));
+            this._register(this.instantiationService.invokeFunction(hookUpSymbolAttachmentDragAndContextMenu, this.element, scopedContextKeyService, { ...attachment, kind: attachment.symbolKind }, MenuId.ChatInputSymbolAttachmentContext));
+        }
+        if (resource) {
+            this.addResourceOpenHandlers(resource, range);
+        }
+        this.attachClearButton();
+    }
+};
+DefaultChatAttachmentWidget = ( __decorate([
+    ( __param(8, ICommandService)),
+    ( __param(9, IOpenerService)),
+    ( __param(10, IContextKeyService)),
+    ( __param(11, IInstantiationService))
+], DefaultChatAttachmentWidget));
+let PromptFileAttachmentWidget = class PromptFileAttachmentWidget extends AbstractChatAttachmentWidget {
+    constructor(attachment, currentLanguageModel, options, container, contextResourceLabels, commandService, openerService, labelService, instantiationService) {
+        super(attachment, options, container, contextResourceLabels, currentLanguageModel, commandService, openerService);
+        this.labelService = labelService;
+        this.instantiationService = instantiationService;
+        this.hintElement = append(this.element, $('span.prompt-type'));
+        this.updateLabel(attachment);
+        this.instantiationService.invokeFunction(accessor => {
+            this._register(hookUpResourceAttachmentDragAndContextMenu(accessor, this.element, attachment.value));
+        });
+        this.addResourceOpenHandlers(attachment.value, undefined);
+        this.attachClearButton();
+    }
+    updateLabel(attachment) {
+        const resource = attachment.value;
+        const fileBasename = basename(resource.path);
+        const fileDirname = dirname(resource.path);
+        const friendlyName = `${fileBasename} ${fileDirname}`;
+        const isPrompt = attachment.id.startsWith(PromptFileVariableKind.PromptFile);
+        const ariaLabel = isPrompt
+            ? ( localize(5029, "Prompt file, {0}", friendlyName))
+            : ( localize(5030, "Instructions attachment, {0}", friendlyName));
+        const typeLabel = isPrompt
+            ? ( localize(5031, "Prompt"))
+            : ( localize(5032, "Instructions"));
+        const title = this.labelService.getUriLabel(resource) + (attachment.originLabel ? `\n${attachment.originLabel}` : '');
+        this.element.classList.remove('warning', 'error');
+        const fileWithoutExtension = getCleanPromptName(resource);
+        this.label.setFile(URI.file(fileWithoutExtension), {
+            fileKind: FileKind.FILE,
+            hidePath: true,
+            range: undefined,
+            title,
+            icon: ThemeIcon.fromId(Codicon.bookmark.id),
+            extraClasses: [],
+        });
+        this.hintElement.innerText = typeLabel;
+        this.element.ariaLabel = ariaLabel;
+    }
+};
+PromptFileAttachmentWidget = ( __decorate([
+    ( __param(5, ICommandService)),
+    ( __param(6, IOpenerService)),
+    ( __param(7, ILabelService)),
+    ( __param(8, IInstantiationService))
+], PromptFileAttachmentWidget));
+let PromptTextAttachmentWidget = class PromptTextAttachmentWidget extends AbstractChatAttachmentWidget {
+    constructor(attachment, currentLanguageModel, options, container, contextResourceLabels, commandService, openerService, preferencesService, hoverService) {
+        super(attachment, options, container, contextResourceLabels, currentLanguageModel, commandService, openerService);
+        if (attachment.settingId) {
+            const openSettings = () => preferencesService.openSettings({ jsonEditor: false, query: `@id:${attachment.settingId}` });
+            this.element.style.cursor = 'pointer';
+            this._register(addDisposableListener(this.element, EventType.CLICK, async (e) => {
+                EventHelper.stop(e, true);
+                openSettings();
+            }));
+            this._register(addDisposableListener(this.element, EventType.KEY_DOWN, async (e) => {
+                const event = ( new StandardKeyboardEvent(e));
+                if (event.equals(KeyCode.Enter) || event.equals(KeyCode.Space)) {
+                    EventHelper.stop(e, true);
+                    openSettings();
+                }
+            }));
+        }
+        this.label.setLabel(( localize(5033, 'Additional Instructions')), undefined, undefined);
+        this._register(hoverService.setupDelayedHover(this.element, {
+            ...commonHoverOptions,
+            content: attachment.value,
+        }, commonHoverLifecycleOptions));
+    }
+};
+PromptTextAttachmentWidget = ( __decorate([
+    ( __param(5, ICommandService)),
+    ( __param(6, IOpenerService)),
+    ( __param(7, IPreferencesService)),
+    ( __param(8, IHoverService))
+], PromptTextAttachmentWidget));
+let ToolSetOrToolItemAttachmentWidget = class ToolSetOrToolItemAttachmentWidget extends AbstractChatAttachmentWidget {
+    constructor(attachment, currentLanguageModel, options, container, contextResourceLabels, toolsService, commandService, openerService, hoverService) {
+        super(attachment, options, container, contextResourceLabels, currentLanguageModel, commandService, openerService);
+        const toolOrToolSet = Iterable.find(toolsService.getTools(), tool => tool.id === attachment.id) ?? Iterable.find(toolsService.toolSets.get(), toolSet => toolSet.id === attachment.id);
+        let name = attachment.name;
+        const icon = attachment.icon ?? Codicon.tools;
+        if (toolOrToolSet instanceof ToolSet) {
+            name = toolOrToolSet.referenceName;
+        }
+        else if (toolOrToolSet) {
+            name = toolOrToolSet.toolReferenceName ?? name;
+        }
+        this.label.setLabel(`$(${icon.id})\u00A0${name}`, undefined);
+        this.element.style.cursor = 'pointer';
+        this.element.ariaLabel = ( localize(5028, "Attached context, {0}", name));
+        let hoverContent;
+        if (toolOrToolSet instanceof ToolSet) {
+            hoverContent = ( localize(
+                5034,
+                "{0} - {1}",
+                toolOrToolSet.description ?? toolOrToolSet.referenceName,
+                toolOrToolSet.source.label
+            ));
+        }
+        else if (toolOrToolSet) {
+            hoverContent = ( localize(
+                5035,
+                "{0} - {1}",
+                toolOrToolSet.userDescription ?? toolOrToolSet.modelDescription,
+                toolOrToolSet.source.label
+            ));
+        }
+        if (hoverContent) {
+            this._register(hoverService.setupDelayedHover(this.element, {
+                ...commonHoverOptions,
+                content: hoverContent,
+            }, commonHoverLifecycleOptions));
+        }
+        this.attachClearButton();
+    }
+};
+ToolSetOrToolItemAttachmentWidget = ( __decorate([
+    ( __param(5, ILanguageModelToolsService)),
+    ( __param(6, ICommandService)),
+    ( __param(7, IOpenerService)),
+    ( __param(8, IHoverService))
+], ToolSetOrToolItemAttachmentWidget));
+let NotebookCellOutputChatAttachmentWidget = class NotebookCellOutputChatAttachmentWidget extends AbstractChatAttachmentWidget {
+    constructor(resource, attachment, currentLanguageModel, options, container, contextResourceLabels, commandService, openerService, hoverService, languageModelsService, notebookService, instantiationService) {
+        super(attachment, options, container, contextResourceLabels, currentLanguageModel, commandService, openerService);
+        this.hoverService = hoverService;
+        this.languageModelsService = languageModelsService;
+        this.notebookService = notebookService;
+        this.instantiationService = instantiationService;
+        switch (attachment.mimeType) {
+            case 'application/vnd.code.notebook.error': {
+                this.renderErrorOutput(resource, attachment);
+                break;
+            }
+            case 'image/png':
+            case 'image/jpeg':
+            case 'image/svg': {
+                this.renderImageOutput(resource, attachment);
+                break;
+            }
+            default: {
+                this.renderGenericOutput(resource, attachment);
+            }
+        }
+        this.instantiationService.invokeFunction(accessor => {
+            this._register(hookUpResourceAttachmentDragAndContextMenu(accessor, this.element, resource));
+        });
+        this.addResourceOpenHandlers(resource, undefined);
+        this.attachClearButton();
+    }
+    getAriaLabel(attachment) {
+        return localize(5036, "Attached Notebook output, {0}", attachment.name);
+    }
+    renderErrorOutput(resource, attachment) {
+        const attachmentLabel = attachment.name;
+        const withIcon = attachment.icon?.id ? `$(${attachment.icon.id})\u00A0${attachmentLabel}` : attachmentLabel;
+        const buffer = this.getOutputItem(resource, attachment)?.data.buffer ?? ( new Uint8Array());
+        let title = undefined;
+        try {
+            const error = JSON.parse(( new TextDecoder()).decode(buffer));
+            if (error.name && error.message) {
+                title = `${error.name}: ${error.message}`;
+            }
+        }
+        catch {
+        }
+        this.label.setLabel(withIcon, undefined, { title });
+        this.element.ariaLabel = this.getAriaLabel(attachment);
+    }
+    renderGenericOutput(resource, attachment) {
+        this.element.ariaLabel = this.getAriaLabel(attachment);
+        this.label.setFile(resource, { hidePath: true, icon: ThemeIcon.fromId('output') });
+    }
+    renderImageOutput(resource, attachment) {
+        let ariaLabel;
+        if (attachment.omittedState === OmittedState.Full) {
+            ariaLabel = ( localize(5037, "Omitted this Notebook ouput: {0}", attachment.name));
+        }
+        else if (attachment.omittedState === OmittedState.Partial) {
+            ariaLabel = ( localize(5038, "Partially omitted this Notebook output: {0}", attachment.name));
+        }
+        else {
+            ariaLabel = this.getAriaLabel(attachment);
+        }
+        const clickHandler = async () => await this.openResource(resource, { editorOptions: { preserveFocus: true } }, false, undefined);
+        const currentLanguageModelName = this.currentLanguageModel ? this.languageModelsService.lookupLanguageModel(this.currentLanguageModel.identifier)?.name ?? this.currentLanguageModel.identifier : undefined;
+        const buffer = this.getOutputItem(resource, attachment)?.data.buffer ?? ( new Uint8Array());
+        this._register(createImageElements(resource, attachment.name, attachment.name, this.element, buffer, this.hoverService, ariaLabel, currentLanguageModelName, clickHandler, this.currentLanguageModel, attachment.omittedState));
+    }
+    getOutputItem(resource, attachment) {
+        const parsedInfo = CellUri.parseCellOutputUri(resource);
+        if (!parsedInfo || typeof parsedInfo.cellHandle !== 'number' || typeof parsedInfo.outputIndex !== 'number') {
+            return undefined;
+        }
+        const notebook = this.notebookService.getNotebookTextModel(parsedInfo.notebook);
+        if (!notebook) {
+            return undefined;
+        }
+        const cell = notebook.cells.find(c => c.handle === parsedInfo.cellHandle);
+        if (!cell) {
+            return undefined;
+        }
+        const output = cell.outputs.length > parsedInfo.outputIndex ? cell.outputs[parsedInfo.outputIndex] : undefined;
+        return output?.outputs.find(o => o.mime === attachment.mimeType);
+    }
+};
+NotebookCellOutputChatAttachmentWidget = ( __decorate([
+    ( __param(6, ICommandService)),
+    ( __param(7, IOpenerService)),
+    ( __param(8, IHoverService)),
+    ( __param(9, ILanguageModelsService)),
+    ( __param(10, INotebookService)),
+    ( __param(11, IInstantiationService))
+], NotebookCellOutputChatAttachmentWidget));
+let ElementChatAttachmentWidget = class ElementChatAttachmentWidget extends AbstractChatAttachmentWidget {
+    constructor(attachment, currentLanguageModel, options, container, contextResourceLabels, commandService, openerService, editorService) {
+        super(attachment, options, container, contextResourceLabels, currentLanguageModel, commandService, openerService);
+        const ariaLabel = ( localize(5039, "Attached element, {0}", attachment.name));
+        this.element.ariaLabel = ariaLabel;
+        this.element.style.position = 'relative';
+        this.element.style.cursor = 'pointer';
+        const attachmentLabel = attachment.name;
+        const withIcon = attachment.icon?.id ? `$(${attachment.icon.id})\u00A0${attachmentLabel}` : attachmentLabel;
+        this.label.setLabel(withIcon, undefined, { title: ( localize(5040, "Click to view the contents of: {0}", attachmentLabel)) });
+        this._register(addDisposableListener(this.element, EventType.CLICK, async () => {
+            const content = attachment.value?.toString() || '';
+            await editorService.openEditor({
+                resource: undefined,
+                contents: content,
+                options: {
+                    pinned: true
+                }
+            });
+        }));
+        this.attachClearButton();
+    }
+};
+ElementChatAttachmentWidget = ( __decorate([
+    ( __param(5, ICommandService)),
+    ( __param(6, IOpenerService)),
+    ( __param(7, IEditorService))
+], ElementChatAttachmentWidget));
+let SCMHistoryItemAttachmentWidget = class SCMHistoryItemAttachmentWidget extends AbstractChatAttachmentWidget {
+    constructor(attachment, currentLanguageModel, options, container, contextResourceLabels, commandService, markdownRendererService, hoverService, openerService, themeService) {
+        super(attachment, options, container, contextResourceLabels, currentLanguageModel, commandService, openerService);
+        this.label.setLabel(attachment.name, undefined);
+        this.element.style.cursor = 'pointer';
+        this.element.ariaLabel = ( localize(5028, "Attached context, {0}", attachment.name));
+        const { content, disposables } = toHistoryItemHoverContent(markdownRendererService, attachment.historyItem, false);
+        this._store.add(hoverService.setupDelayedHover(this.element, {
+            ...commonHoverOptions,
+            content,
+        }, commonHoverLifecycleOptions));
+        this._store.add(disposables);
+        this._store.add(addDisposableListener(this.element, EventType.CLICK, (e) => {
+            EventHelper.stop(e, true);
+            this._openAttachment(attachment);
+        }));
+        this._store.add(addDisposableListener(this.element, EventType.KEY_DOWN, (e) => {
+            const event = ( new StandardKeyboardEvent(e));
+            if (event.equals(KeyCode.Enter) || event.equals(KeyCode.Space)) {
+                EventHelper.stop(e, true);
+                this._openAttachment(attachment);
+            }
+        }));
+        this.attachClearButton();
+    }
+    async _openAttachment(attachment) {
+        await this.commandService.executeCommand('_workbench.openMultiDiffEditor', {
+            title: getHistoryItemEditorTitle(attachment.historyItem), multiDiffSourceUri: attachment.value
+        });
+    }
+};
+SCMHistoryItemAttachmentWidget = ( __decorate([
+    ( __param(5, ICommandService)),
+    ( __param(6, IMarkdownRendererService)),
+    ( __param(7, IHoverService)),
+    ( __param(8, IOpenerService)),
+    ( __param(9, IThemeService))
+], SCMHistoryItemAttachmentWidget));
+let SCMHistoryItemChangeAttachmentWidget = class SCMHistoryItemChangeAttachmentWidget extends AbstractChatAttachmentWidget {
+    constructor(attachment, currentLanguageModel, options, container, contextResourceLabels, commandService, hoverService, markdownRendererService, openerService, themeService, editorService) {
+        super(attachment, options, container, contextResourceLabels, currentLanguageModel, commandService, openerService);
+        this.editorService = editorService;
+        const nameSuffix = `\u00A0$(${Codicon.gitCommit.id})${attachment.historyItem.displayId ?? attachment.historyItem.id}`;
+        this.label.setFile(attachment.value, { fileKind: FileKind.FILE, hidePath: true, nameSuffix });
+        this.element.ariaLabel = ( localize(5028, "Attached context, {0}", attachment.name));
+        const { content, disposables } = toHistoryItemHoverContent(markdownRendererService, attachment.historyItem, false);
+        this._store.add(hoverService.setupDelayedHover(this.element, {
+            ...commonHoverOptions, content,
+        }, commonHoverLifecycleOptions));
+        this._store.add(disposables);
+        this.addResourceOpenHandlers(attachment.value, undefined);
+        this.attachClearButton();
+    }
+    async openResource(resource, options, isDirectory, range) {
+        const attachment = this.attachment;
+        const historyItem = attachment.historyItem;
+        await this.editorService.openEditor({
+            resource,
+            label: `${basename(resource.path)} (${historyItem.displayId ?? historyItem.id})`,
+            options: { ...options.editorOptions }
+        }, options.openToSide ? SIDE_GROUP : undefined);
+    }
+};
+SCMHistoryItemChangeAttachmentWidget = ( __decorate([
+    ( __param(5, ICommandService)),
+    ( __param(6, IHoverService)),
+    ( __param(7, IMarkdownRendererService)),
+    ( __param(8, IOpenerService)),
+    ( __param(9, IThemeService)),
+    ( __param(10, IEditorService))
+], SCMHistoryItemChangeAttachmentWidget));
+let SCMHistoryItemChangeRangeAttachmentWidget = class SCMHistoryItemChangeRangeAttachmentWidget extends AbstractChatAttachmentWidget {
+    constructor(attachment, currentLanguageModel, options, container, contextResourceLabels, commandService, openerService, editorService) {
+        super(attachment, options, container, contextResourceLabels, currentLanguageModel, commandService, openerService);
+        this.editorService = editorService;
+        const historyItemStartId = attachment.historyItemChangeStart.historyItem.displayId ?? attachment.historyItemChangeStart.historyItem.id;
+        const historyItemEndId = attachment.historyItemChangeEnd.historyItem.displayId ?? attachment.historyItemChangeEnd.historyItem.id;
+        const nameSuffix = `\u00A0$(${Codicon.gitCommit.id})${historyItemStartId}..${historyItemEndId}`;
+        this.label.setFile(attachment.value, { fileKind: FileKind.FILE, hidePath: true, nameSuffix });
+        this.element.ariaLabel = ( localize(5028, "Attached context, {0}", attachment.name));
+        this.addResourceOpenHandlers(attachment.value, undefined);
+        this.attachClearButton();
+    }
+    async openResource(resource, options, isDirectory, range) {
+        const attachment = this.attachment;
+        const historyItemChangeStart = attachment.historyItemChangeStart;
+        const historyItemChangeEnd = attachment.historyItemChangeEnd;
+        const originalUriTitle = `${basename(historyItemChangeStart.uri.fsPath)} (${historyItemChangeStart.historyItem.displayId ?? historyItemChangeStart.historyItem.id})`;
+        const modifiedUriTitle = `${basename(historyItemChangeEnd.uri.fsPath)} (${historyItemChangeEnd.historyItem.displayId ?? historyItemChangeEnd.historyItem.id})`;
+        await this.editorService.openEditor({
+            original: { resource: historyItemChangeStart.uri },
+            modified: { resource: historyItemChangeEnd.uri },
+            label: `${originalUriTitle} ↔ ${modifiedUriTitle}`,
+            options: { ...options.editorOptions }
+        }, options.openToSide ? SIDE_GROUP : undefined);
+    }
+};
+SCMHistoryItemChangeRangeAttachmentWidget = ( __decorate([
+    ( __param(5, ICommandService)),
+    ( __param(6, IOpenerService)),
+    ( __param(7, IEditorService))
+], SCMHistoryItemChangeRangeAttachmentWidget));
+function hookUpResourceAttachmentDragAndContextMenu(accessor, widget, resource) {
+    const contextKeyService = accessor.get(IContextKeyService);
+    const instantiationService = accessor.get(IInstantiationService);
+    const store = ( new DisposableStore());
+    const scopedContextKeyService = store.add(contextKeyService.createScoped(widget));
+    store.add(setResourceContext(accessor, scopedContextKeyService, resource));
+    widget.draggable = true;
+    store.add(addDisposableListener(widget, 'dragstart', e => {
+        instantiationService.invokeFunction(accessor => fillEditorsDragData(accessor, [resource], e));
+        e.dataTransfer?.setDragImage(widget, 0, 0);
+    }));
+    store.add(addBasicContextMenu(accessor, widget, scopedContextKeyService, MenuId.ChatInputResourceAttachmentContext, resource));
+    return store;
+}
+function hookUpSymbolAttachmentDragAndContextMenu(accessor, widget, scopedContextKeyService, attachment, contextMenuId) {
+    const instantiationService = accessor.get(IInstantiationService);
+    const languageFeaturesService = accessor.get(ILanguageFeaturesService);
+    const textModelService = accessor.get(ITextModelService);
+    const store = ( new DisposableStore());
+    store.add(setResourceContext(accessor, scopedContextKeyService, attachment.value.uri));
+    const chatResourceContext = chatAttachmentResourceContextKey.bindTo(scopedContextKeyService);
+    chatResourceContext.set(( attachment.value.uri.toString()));
+    widget.draggable = true;
+    store.add(addDisposableListener(widget, 'dragstart', e => {
+        instantiationService.invokeFunction(accessor => fillEditorsDragData(accessor, [{ resource: attachment.value.uri, selection: attachment.value.range }], e));
+        fillInSymbolsDragData([{
+                fsPath: attachment.value.uri.fsPath,
+                range: attachment.value.range,
+                name: attachment.name,
+                kind: attachment.kind,
+            }], e);
+        e.dataTransfer?.setDragImage(widget, 0, 0);
+    }));
+    const providerContexts = [
+        [EditorContextKeys.hasDefinitionProvider.bindTo(scopedContextKeyService), languageFeaturesService.definitionProvider],
+        [EditorContextKeys.hasReferenceProvider.bindTo(scopedContextKeyService), languageFeaturesService.referenceProvider],
+        [EditorContextKeys.hasImplementationProvider.bindTo(scopedContextKeyService), languageFeaturesService.implementationProvider],
+        [EditorContextKeys.hasTypeDefinitionProvider.bindTo(scopedContextKeyService), languageFeaturesService.typeDefinitionProvider],
+    ];
+    const updateContextKeys = async () => {
+        const modelRef = await textModelService.createModelReference(attachment.value.uri);
+        try {
+            const model = modelRef.object.textEditorModel;
+            for (const [contextKey, registry] of providerContexts) {
+                contextKey.set(( registry.has(model)));
+            }
+        }
+        finally {
+            modelRef.dispose();
+        }
+    };
+    store.add(addBasicContextMenu(accessor, widget, scopedContextKeyService, contextMenuId, attachment.value, updateContextKeys));
+    return store;
+}
+function setResourceContext(accessor, scopedContextKeyService, resource) {
+    const fileService = accessor.get(IFileService);
+    const languageService = accessor.get(ILanguageService);
+    const modelService = accessor.get(IModelService);
+    const resourceContextKey = ( new ResourceContextKey(scopedContextKeyService, fileService, languageService, modelService));
+    resourceContextKey.set(resource);
+    return resourceContextKey;
+}
+function addBasicContextMenu(accessor, widget, scopedContextKeyService, menuId, arg, updateContextKeys) {
+    const contextMenuService = accessor.get(IContextMenuService);
+    const menuService = accessor.get(IMenuService);
+    return addDisposableListener(widget, EventType.CONTEXT_MENU, async (domEvent) => {
+        const event = ( new StandardMouseEvent(getWindow(domEvent), domEvent));
+        EventHelper.stop(domEvent, true);
+        try {
+            await updateContextKeys?.();
+        }
+        catch (e) {
+            console.error(e);
+        }
+        contextMenuService.showContextMenu({
+            contextKeyService: scopedContextKeyService,
+            getAnchor: () => event,
+            getActions: () => {
+                const menu = menuService.getMenuActions(menuId, scopedContextKeyService, { arg });
+                return getFlatContextMenuActions(menu);
+            },
+        });
+    });
+}
+const chatAttachmentResourceContextKey = ( new RawContextKey(
+    'chatAttachmentResource',
+    undefined,
+    { type: 'URI', description: ( localize(
+        5041,
+        "The full value of the chat attachment resource, including scheme and path"
+    )) }
+));
+
+export { DefaultChatAttachmentWidget, ElementChatAttachmentWidget, FileAttachmentWidget, ImageAttachmentWidget, NotebookCellOutputChatAttachmentWidget, PasteAttachmentWidget, PromptFileAttachmentWidget, PromptTextAttachmentWidget, SCMHistoryItemAttachmentWidget, SCMHistoryItemChangeAttachmentWidget, SCMHistoryItemChangeRangeAttachmentWidget, TerminalCommandAttachmentWidget, ToolSetOrToolItemAttachmentWidget, chatAttachmentResourceContextKey, hookUpResourceAttachmentDragAndContextMenu, hookUpSymbolAttachmentDragAndContextMenu };