@codingame/monaco-vscode-katex-common 24.1.0

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

@@ -0,0 +1,69 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { IChatService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService.service';
+import { isResponseVM } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatViewModel';
+import { IChatWidgetService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service';
+import { SimpleChatConfirmationWidget } from './chatConfirmationWidget.js';
+
+let ChatConfirmationContentPart = class ChatConfirmationContentPart extends Disposable {
+    constructor(confirmation, context, instantiationService, chatService, chatWidgetService) {
+        super();
+        this.instantiationService = instantiationService;
+        this.chatService = chatService;
+        this._onDidChangeHeight = this._register(( new Emitter()));
+        this.onDidChangeHeight = this._onDidChangeHeight.event;
+        const element = context.element;
+        const buttons = confirmation.buttons
+            ? ( confirmation.buttons.map(button => ({
+                label: button,
+                data: confirmation.data,
+                isSecondary: button !== confirmation.buttons?.[0],
+            })))
+            : [
+                { label: ( localize(5050, "Accept")), data: confirmation.data },
+                { label: ( localize(5051, "Dismiss")), data: confirmation.data, isSecondary: true },
+            ];
+        const confirmationWidget = this._register(this.instantiationService.createInstance(SimpleChatConfirmationWidget, context, { title: confirmation.title, buttons, message: confirmation.message, silent: confirmation.isLive === false }));
+        confirmationWidget.setShowButtons(!confirmation.isUsed);
+        this._register(confirmationWidget.onDidChangeHeight(() => this._onDidChangeHeight.fire()));
+        this._register(confirmationWidget.onDidClick(async (e) => {
+            if (isResponseVM(element)) {
+                const prompt = `${e.label}: "${confirmation.title}"`;
+                const options = e.isSecondary ?
+                    { rejectedConfirmationData: [e.data] } :
+                    { acceptedConfirmationData: [e.data] };
+                options.agentId = element.agent?.id;
+                options.slashCommand = element.slashCommand?.name;
+                options.confirmation = e.label;
+                const widget = chatWidgetService.getWidgetBySessionResource(element.sessionResource);
+                options.userSelectedModelId = widget?.input.currentLanguageModel;
+                options.modeInfo = widget?.input.currentModeInfo;
+                options.location = widget?.location;
+                Object.assign(options, widget?.getModeRequestOptions());
+                if (await this.chatService.sendRequest(element.sessionResource, prompt, options)) {
+                    confirmation.isUsed = true;
+                    confirmationWidget.setShowButtons(false);
+                    this._onDidChangeHeight.fire();
+                }
+            }
+        }));
+        this.domNode = confirmationWidget.domNode;
+    }
+    hasSameContent(other) {
+        return other.kind === 'confirmation';
+    }
+    addDisposable(disposable) {
+        this._register(disposable);
+    }
+};
+ChatConfirmationContentPart = ( __decorate([
+    ( __param(2, IInstantiationService)),
+    ( __param(3, IChatService)),
+    ( __param(4, IChatWidgetService))
+], ChatConfirmationContentPart));
+
+export { ChatConfirmationContentPart };

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

@@ -0,0 +1,116 @@
+import { Separator } from "@codingame/monaco-vscode-api/vscode/vs/base/common/actions";
+import { Emitter, Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
+import { IMarkdownString } from "@codingame/monaco-vscode-api/vscode/vs/base/common/htmlContent";
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import type { ThemeIcon } from "@codingame/monaco-vscode-api/vscode/vs/base/common/themables";
+import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+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 { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { IMarkdownRendererService } from "@codingame/monaco-vscode-api/vscode/vs/platform/markdown/browser/markdownRenderer.service";
+import { IChatContentPartRenderContext } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chatContentParts/chatContentParts";
+import { IChatMarkdownAnchorService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chatContentParts/chatMarkdownAnchorService.service";
+export interface IChatConfirmationButton<T> {
+    label: string;
+    isSecondary?: boolean;
+    tooltip?: string;
+    data: T;
+    disabled?: boolean;
+    readonly onDidChangeDisablement?: Event<boolean>;
+    moreActions?: (IChatConfirmationButton<T> | Separator)[];
+}
+export interface IChatConfirmationWidgetOptions<T> {
+    title: string | IMarkdownString;
+    message: string | IMarkdownString;
+    subtitle?: string | IMarkdownString;
+    buttons: IChatConfirmationButton<T>[];
+    toolbarData?: {
+        arg: unknown;
+        partType: string;
+        partSource?: string;
+    };
+    silent?: boolean;
+}
+export declare class ChatQueryTitlePart extends Disposable {
+    private readonly element;
+    private _title;
+    private readonly _renderer;
+    private readonly _onDidChangeHeight;
+    readonly onDidChangeHeight: Event<void>;
+    private readonly _renderedTitle;
+    get title(): string | IMarkdownString;
+    set title(value: string | IMarkdownString);
+    constructor(element: HTMLElement, _title: IMarkdownString | string, subtitle: string | IMarkdownString | undefined, _renderer: IMarkdownRendererService);
+    private toMdString;
+}
+declare abstract class BaseSimpleChatConfirmationWidget<T> extends Disposable {
+    protected readonly context: IChatContentPartRenderContext;
+    protected readonly instantiationService: IInstantiationService;
+    protected readonly _markdownRendererService: IMarkdownRendererService;
+    private readonly _configurationService;
+    private _onDidClick;
+    get onDidClick(): Event<IChatConfirmationButton<T>>;
+    protected _onDidChangeHeight: Emitter<void>;
+    get onDidChangeHeight(): Event<void>;
+    private _domNode;
+    get domNode(): HTMLElement;
+    private get showingButtons();
+    setShowButtons(showButton: boolean): void;
+    private readonly messageElement;
+    private readonly silent;
+    private readonly notificationManager;
+    constructor(context: IChatContentPartRenderContext, options: IChatConfirmationWidgetOptions<T>, instantiationService: IInstantiationService, _markdownRendererService: IMarkdownRendererService, contextMenuService: IContextMenuService, _configurationService: IConfigurationService, contextKeyService: IContextKeyService);
+    protected renderMessage(element: HTMLElement, listContainer: HTMLElement): void;
+}
+/** @deprecated Use ChatConfirmationWidget instead */
+export declare class SimpleChatConfirmationWidget<T> extends BaseSimpleChatConfirmationWidget<T> {
+    private _renderedMessage;
+    constructor(context: IChatContentPartRenderContext, options: IChatConfirmationWidgetOptions<T>, instantiationService: IInstantiationService, markdownRendererService: IMarkdownRendererService, contextMenuService: IContextMenuService, configurationService: IConfigurationService, contextKeyService: IContextKeyService);
+    updateMessage(message: string | IMarkdownString): void;
+}
+export interface IChatConfirmationWidget2Options<T> {
+    title: string | IMarkdownString;
+    message: string | IMarkdownString | HTMLElement;
+    icon?: ThemeIcon;
+    subtitle?: string | IMarkdownString;
+    buttons: IChatConfirmationButton<T>[];
+    toolbarData?: {
+        arg: unknown;
+        partType: string;
+        partSource?: string;
+    };
+}
+declare abstract class BaseChatConfirmationWidget<T> extends Disposable {
+    protected readonly _context: IChatContentPartRenderContext;
+    protected readonly instantiationService: IInstantiationService;
+    protected readonly markdownRendererService: IMarkdownRendererService;
+    private readonly contextMenuService;
+    private readonly _configurationService;
+    private readonly chatMarkdownAnchorService;
+    private _onDidClick;
+    get onDidClick(): Event<IChatConfirmationButton<T>>;
+    protected _onDidChangeHeight: Emitter<void>;
+    get onDidChangeHeight(): Event<void>;
+    private _domNode;
+    get domNode(): HTMLElement;
+    private _buttonsDomNode;
+    private get showingButtons();
+    setShowButtons(showButton: boolean): void;
+    private readonly messageElement;
+    private readonly markdownContentPart;
+    private readonly notificationManager;
+    get codeblocksPartId(): string | undefined;
+    get codeblocks(): import("@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat").IChatCodeBlockInfo[] | undefined;
+    constructor(_context: IChatContentPartRenderContext, options: IChatConfirmationWidget2Options<T>, instantiationService: IInstantiationService, markdownRendererService: IMarkdownRendererService, contextMenuService: IContextMenuService, _configurationService: IConfigurationService, contextKeyService: IContextKeyService, chatMarkdownAnchorService: IChatMarkdownAnchorService);
+    updateButtons(buttons: IChatConfirmationButton<T>[]): void;
+    protected renderMessage(element: HTMLElement | IMarkdownString | string, listContainer: HTMLElement): void;
+}
+export declare class ChatConfirmationWidget<T> extends BaseChatConfirmationWidget<T> {
+    private _renderedMessage;
+    constructor(context: IChatContentPartRenderContext, options: IChatConfirmationWidget2Options<T>, instantiationService: IInstantiationService, markdownRendererService: IMarkdownRendererService, contextMenuService: IContextMenuService, configurationService: IConfigurationService, contextKeyService: IContextKeyService, chatMarkdownAnchorService: IChatMarkdownAnchorService);
+    updateMessage(message: string | IMarkdownString): void;
+}
+export declare class ChatCustomConfirmationWidget<T> extends BaseChatConfirmationWidget<T> {
+    constructor(context: IChatContentPartRenderContext, options: IChatConfirmationWidget2Options<T>, instantiationService: IInstantiationService, markdownRendererService: IMarkdownRendererService, contextMenuService: IContextMenuService, configurationService: IConfigurationService, contextKeyService: IContextKeyService, chatMarkdownAnchorService: IChatMarkdownAnchorService);
+}
+export {};

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

@@ -0,0 +1,417 @@
+
+import { registerCss } from '@codingame/monaco-vscode-api/css';
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { createElement, triggerNotification, h, getWindow, isHTMLElement } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { ButtonWithDropdown, Button } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/button/button';
+import { Separator, Action } from '@codingame/monaco-vscode-api/vscode/vs/base/common/actions';
+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 { Disposable, MutableDisposable, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { MenuWorkbenchToolBar } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/browser/toolbar';
+import { MenuId } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+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 { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { ServiceCollection } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/serviceCollection';
+import { IMarkdownRendererService } from '@codingame/monaco-vscode-api/vscode/vs/platform/markdown/browser/markdownRenderer.service';
+import { FocusMode } from '@codingame/monaco-vscode-api/vscode/vs/platform/native/common/native';
+import { defaultButtonStyles } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/browser/defaultStyles';
+import { IHostService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/host/browser/host.service';
+import { IChatWidgetService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service';
+import { renderFileWidgets } from '../chatInlineAnchorWidget.js';
+import { IChatMarkdownAnchorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chatContentParts/chatMarkdownAnchorService.service';
+import { ChatMarkdownContentPart } from './chatMarkdownContentPart.js';
+import * as chatConfirmationWidget from './media/chatConfirmationWidget.css';
+
+registerCss(chatConfirmationWidget);
+let ChatQueryTitlePart = class ChatQueryTitlePart extends Disposable {
+    get title() {
+        return this._title;
+    }
+    set title(value) {
+        this._title = value;
+        const next = this._renderer.render(this.toMdString(value), {
+            asyncRenderCallback: () => this._onDidChangeHeight.fire(),
+        });
+        const previousEl = this._renderedTitle.value?.element;
+        if (previousEl?.parentElement) {
+            previousEl.replaceWith(next.element);
+        }
+        else {
+            this.element.appendChild(next.element);
+        }
+        this._renderedTitle.value = next;
+    }
+    constructor(element, _title, subtitle, _renderer) {
+        super();
+        this.element = element;
+        this._title = _title;
+        this._renderer = _renderer;
+        this._onDidChangeHeight = this._register(( new Emitter()));
+        this.onDidChangeHeight = this._onDidChangeHeight.event;
+        this._renderedTitle = this._register(( new MutableDisposable()));
+        element.classList.add('chat-query-title-part');
+        this._renderedTitle.value = _renderer.render(this.toMdString(_title), {
+            asyncRenderCallback: () => this._onDidChangeHeight.fire(),
+        });
+        element.append(this._renderedTitle.value.element);
+        if (subtitle) {
+            const str = this.toMdString(subtitle);
+            const renderedTitle = this._register(_renderer.render(str, {
+                asyncRenderCallback: () => this._onDidChangeHeight.fire(),
+            }));
+            const wrapper = createElement('small');
+            wrapper.appendChild(renderedTitle.element);
+            element.append(wrapper);
+        }
+    }
+    toMdString(value) {
+        if (typeof value === 'string') {
+            return ( new MarkdownString('', { supportThemeIcons: true })).appendText(value);
+        }
+        else {
+            return ( new MarkdownString(value.value, { supportThemeIcons: true, isTrusted: value.isTrusted }));
+        }
+    }
+};
+ChatQueryTitlePart = ( __decorate([
+    ( __param(3, IMarkdownRendererService))
+], ChatQueryTitlePart));
+let ChatConfirmationNotifier = class ChatConfirmationNotifier extends Disposable {
+    constructor(_hostService, _chatWidgetService) {
+        super();
+        this._hostService = _hostService;
+        this._chatWidgetService = _chatWidgetService;
+        this.disposables = this._register(( new MutableDisposable()));
+    }
+    async notify(targetWindow, sessionResource) {
+        this._hostService.focus(targetWindow, { mode: FocusMode.Notify });
+        const widget = this._chatWidgetService.getWidgetBySessionResource(sessionResource);
+        const title = widget?.viewModel?.model.title ? ( localize(5052, "Chat: {0}", widget.viewModel.model.title)) : ( localize(5053, "Untitled Chat"));
+        const notification = await triggerNotification(title, {
+            detail: ( localize(5054, "Approval needed to continue."))
+        });
+        if (notification) {
+            const disposables = this.disposables.value = ( new DisposableStore());
+            disposables.add(notification);
+            disposables.add(Event.once(notification.onClick)(async () => {
+                await this._hostService.focus(targetWindow, { mode: FocusMode.Force });
+                if (widget) {
+                    await this._chatWidgetService.reveal(widget);
+                    widget.focusInput();
+                }
+                disposables.dispose();
+            }));
+            disposables.add(this._hostService.onDidChangeFocus(focus => {
+                if (focus) {
+                    disposables.dispose();
+                }
+            }));
+        }
+    }
+};
+ChatConfirmationNotifier = ( __decorate([
+    ( __param(0, IHostService)),
+    ( __param(1, IChatWidgetService))
+], ChatConfirmationNotifier));
+let BaseSimpleChatConfirmationWidget = class BaseSimpleChatConfirmationWidget extends Disposable {
+    get onDidClick() { return this._onDidClick.event; }
+    get onDidChangeHeight() { return this._onDidChangeHeight.event; }
+    get domNode() {
+        return this._domNode;
+    }
+    get showingButtons() {
+        return !this.domNode.classList.contains('hideButtons');
+    }
+    setShowButtons(showButton) {
+        this.domNode.classList.toggle('hideButtons', !showButton);
+    }
+    constructor(context, options, instantiationService, _markdownRendererService, contextMenuService, _configurationService, contextKeyService) {
+        super();
+        this.context = context;
+        this.instantiationService = instantiationService;
+        this._markdownRendererService = _markdownRendererService;
+        this._configurationService = _configurationService;
+        this._onDidClick = this._register(( new Emitter()));
+        this._onDidChangeHeight = this._register(( new Emitter()));
+        const { title, subtitle, message, buttons, silent } = options;
+        this.silent = !!silent;
+        this.notificationManager = this._register(instantiationService.createInstance(ChatConfirmationNotifier));
+        const elements = h('.chat-confirmation-widget-container@container', [
+            h('.chat-confirmation-widget@root', [
+                h('.chat-confirmation-widget-title@title'),
+                h('.chat-confirmation-widget-message-container', [
+                    h('.chat-confirmation-widget-message@message'),
+                    h('.chat-buttons-container@buttonsContainer', [
+                        h('.chat-buttons@buttons'),
+                        h('.chat-toolbar@toolbar'),
+                    ]),
+                ]),
+            ]),
+        ]);
+        configureAccessibilityContainer(elements.container, title, message);
+        this._domNode = elements.root;
+        const titlePart = this._register(instantiationService.createInstance(ChatQueryTitlePart, elements.title, title, subtitle));
+        this._register(titlePart.onDidChangeHeight(() => this._onDidChangeHeight.fire()));
+        this.messageElement = elements.message;
+        buttons.forEach(buttonData => {
+            const buttonOptions = { ...defaultButtonStyles, secondary: buttonData.isSecondary, title: buttonData.tooltip, disabled: buttonData.disabled };
+            let button;
+            if (buttonData.moreActions) {
+                button = ( new ButtonWithDropdown(elements.buttons, {
+                    ...buttonOptions,
+                    contextMenuProvider: contextMenuService,
+                    addPrimaryActionToDropdown: false,
+                    actions: ( buttonData.moreActions.map(action => {
+                        if (action instanceof Separator) {
+                            return action;
+                        }
+                        return this._register(( new Action(action.label, action.label, undefined, !action.disabled, () => {
+                            this._onDidClick.fire(action);
+                            return Promise.resolve();
+                        })));
+                    })),
+                }));
+            }
+            else {
+                button = ( new Button(elements.buttons, buttonOptions));
+            }
+            this._register(button);
+            button.label = buttonData.label;
+            this._register(button.onDidClick(() => this._onDidClick.fire(buttonData)));
+            if (buttonData.onDidChangeDisablement) {
+                this._register(buttonData.onDidChangeDisablement(disabled => button.enabled = !disabled));
+            }
+        });
+        if (options?.toolbarData) {
+            const overlay = contextKeyService.createOverlay([
+                ['chatConfirmationPartType', options.toolbarData.partType],
+                ['chatConfirmationPartSource', options.toolbarData.partSource],
+            ]);
+            const nestedInsta = this._register(instantiationService.createChild(( new ServiceCollection([IContextKeyService, overlay]))));
+            this._register(nestedInsta.createInstance(MenuWorkbenchToolBar, elements.toolbar, MenuId.ChatConfirmationMenu, {
+                menuOptions: {
+                    arg: options.toolbarData.arg,
+                    shouldForwardArgs: true,
+                }
+            }));
+        }
+    }
+    renderMessage(element, listContainer) {
+        this.messageElement.append(element);
+        if (this.showingButtons && this._configurationService.getValue('chat.notifyWindowOnConfirmation') && !this.silent) {
+            const targetWindow = getWindow(listContainer);
+            if (!targetWindow.document.hasFocus()) {
+                this.notificationManager.notify(targetWindow, this.context.element.sessionResource);
+            }
+        }
+    }
+};
+BaseSimpleChatConfirmationWidget = ( __decorate([
+    ( __param(2, IInstantiationService)),
+    ( __param(3, IMarkdownRendererService)),
+    ( __param(4, IContextMenuService)),
+    ( __param(5, IConfigurationService)),
+    ( __param(6, IContextKeyService))
+], BaseSimpleChatConfirmationWidget));
+let SimpleChatConfirmationWidget = class SimpleChatConfirmationWidget extends BaseSimpleChatConfirmationWidget {
+    constructor(context, options, instantiationService, markdownRendererService, contextMenuService, configurationService, contextKeyService) {
+        super(context, options, instantiationService, markdownRendererService, contextMenuService, configurationService, contextKeyService);
+        this.updateMessage(options.message);
+    }
+    updateMessage(message) {
+        this._renderedMessage?.remove();
+        const renderedMessage = this._register(this._markdownRendererService.render(typeof message === 'string' ? ( new MarkdownString(message)) : message, { asyncRenderCallback: () => this._onDidChangeHeight.fire() }));
+        this.renderMessage(renderedMessage.element, this.context.container);
+        this._renderedMessage = renderedMessage.element;
+    }
+};
+SimpleChatConfirmationWidget = ( __decorate([
+    ( __param(2, IInstantiationService)),
+    ( __param(3, IMarkdownRendererService)),
+    ( __param(4, IContextMenuService)),
+    ( __param(5, IConfigurationService)),
+    ( __param(6, IContextKeyService))
+], SimpleChatConfirmationWidget));
+let BaseChatConfirmationWidget = class BaseChatConfirmationWidget extends Disposable {
+    get onDidClick() { return this._onDidClick.event; }
+    get onDidChangeHeight() { return this._onDidChangeHeight.event; }
+    get domNode() {
+        return this._domNode;
+    }
+    get showingButtons() {
+        return !this.domNode.classList.contains('hideButtons');
+    }
+    setShowButtons(showButton) {
+        this.domNode.classList.toggle('hideButtons', !showButton);
+    }
+    get codeblocksPartId() {
+        return this.markdownContentPart.value?.codeblocksPartId;
+    }
+    get codeblocks() {
+        return this.markdownContentPart.value?.codeblocks;
+    }
+    constructor(_context, options, instantiationService, markdownRendererService, contextMenuService, _configurationService, contextKeyService, chatMarkdownAnchorService) {
+        super();
+        this._context = _context;
+        this.instantiationService = instantiationService;
+        this.markdownRendererService = markdownRendererService;
+        this.contextMenuService = contextMenuService;
+        this._configurationService = _configurationService;
+        this.chatMarkdownAnchorService = chatMarkdownAnchorService;
+        this._onDidClick = this._register(( new Emitter()));
+        this._onDidChangeHeight = this._register(( new Emitter()));
+        this.markdownContentPart = this._register(( new MutableDisposable()));
+        const { title, subtitle, message, buttons, icon } = options;
+        this.notificationManager = this._register(instantiationService.createInstance(ChatConfirmationNotifier));
+        const elements = h('.chat-confirmation-widget-container@container', [
+            h('.chat-confirmation-widget2@root', [
+                h('.chat-confirmation-widget-title', [
+                    h('.chat-title@title'),
+                    h('.chat-toolbar-container@buttonsContainer', [
+                        h('.chat-toolbar@toolbar'),
+                    ]),
+                ]),
+                h('.chat-confirmation-widget-message@message'),
+                h('.chat-confirmation-widget-buttons', [
+                    h('.chat-buttons@buttons'),
+                ]),
+            ]),
+        ]);
+        configureAccessibilityContainer(elements.container, title, message);
+        this._domNode = elements.root;
+        this._buttonsDomNode = elements.buttons;
+        const titlePart = this._register(instantiationService.createInstance(ChatQueryTitlePart, elements.title, ( new MarkdownString(
+            icon ? `$(${icon.id}) ${typeof title === 'string' ? title : title.value}` : typeof title === 'string' ? title : title.value
+        )), subtitle));
+        this._register(titlePart.onDidChangeHeight(() => this._onDidChangeHeight.fire()));
+        this.messageElement = elements.message;
+        this.updateButtons(buttons);
+        if (options?.toolbarData) {
+            const overlay = contextKeyService.createOverlay([
+                ['chatConfirmationPartType', options.toolbarData.partType],
+                ['chatConfirmationPartSource', options.toolbarData.partSource],
+            ]);
+            const nestedInsta = this._register(instantiationService.createChild(( new ServiceCollection([IContextKeyService, overlay]))));
+            this._register(nestedInsta.createInstance(MenuWorkbenchToolBar, elements.toolbar, MenuId.ChatConfirmationMenu, {
+                menuOptions: {
+                    arg: options.toolbarData.arg,
+                    shouldForwardArgs: true,
+                }
+            }));
+        }
+    }
+    updateButtons(buttons) {
+        while (this._buttonsDomNode.children.length > 0) {
+            this._buttonsDomNode.children[0].remove();
+        }
+        for (const buttonData of buttons) {
+            const buttonOptions = { ...defaultButtonStyles, secondary: buttonData.isSecondary, title: buttonData.tooltip, disabled: buttonData.disabled };
+            let button;
+            if (buttonData.moreActions) {
+                button = ( new ButtonWithDropdown(this._buttonsDomNode, {
+                    ...buttonOptions,
+                    contextMenuProvider: this.contextMenuService,
+                    addPrimaryActionToDropdown: false,
+                    actions: ( buttonData.moreActions.map(action => {
+                        if (action instanceof Separator) {
+                            return action;
+                        }
+                        return this._register(( new Action(action.label, action.label, undefined, !action.disabled, () => {
+                            this._onDidClick.fire(action);
+                            return Promise.resolve();
+                        })));
+                    })),
+                }));
+            }
+            else {
+                button = ( new Button(this._buttonsDomNode, buttonOptions));
+            }
+            this._register(button);
+            button.label = buttonData.label;
+            this._register(button.onDidClick(() => this._onDidClick.fire(buttonData)));
+            if (buttonData.onDidChangeDisablement) {
+                this._register(buttonData.onDidChangeDisablement(disabled => button.enabled = !disabled));
+            }
+        }
+    }
+    renderMessage(element, listContainer) {
+        this.markdownContentPart.clear();
+        if (!isHTMLElement(element)) {
+            const part = this._register(this.instantiationService.createInstance(ChatMarkdownContentPart, {
+                kind: 'markdownContent',
+                content: typeof element === 'string' ? ( new MarkdownString()).appendMarkdown(element) : element
+            }, this._context, this._context.editorPool, false, this._context.codeBlockStartIndex, this.markdownRendererService, undefined, this._context.currentWidth(), this._context.codeBlockModelCollection, {
+                allowInlineDiffs: true,
+                horizontalPadding: 6,
+            }));
+            renderFileWidgets(part.domNode, this.instantiationService, this.chatMarkdownAnchorService, this._store);
+            this._register(part.onDidChangeHeight(() => this._onDidChangeHeight.fire()));
+            this.markdownContentPart.value = part;
+            element = part.domNode;
+        }
+        for (const child of this.messageElement.children) {
+            child.remove();
+        }
+        this.messageElement.append(element);
+        if (this.showingButtons && this._configurationService.getValue('chat.notifyWindowOnConfirmation')) {
+            const targetWindow = getWindow(listContainer);
+            if (!targetWindow.document.hasFocus()) {
+                this.notificationManager.notify(targetWindow, this._context.element.sessionResource);
+            }
+        }
+    }
+};
+BaseChatConfirmationWidget = ( __decorate([
+    ( __param(2, IInstantiationService)),
+    ( __param(3, IMarkdownRendererService)),
+    ( __param(4, IContextMenuService)),
+    ( __param(5, IConfigurationService)),
+    ( __param(6, IContextKeyService)),
+    ( __param(7, IChatMarkdownAnchorService))
+], BaseChatConfirmationWidget));
+let ChatConfirmationWidget = class ChatConfirmationWidget extends BaseChatConfirmationWidget {
+    constructor(context, options, instantiationService, markdownRendererService, contextMenuService, configurationService, contextKeyService, chatMarkdownAnchorService) {
+        super(context, options, instantiationService, markdownRendererService, contextMenuService, configurationService, contextKeyService, chatMarkdownAnchorService);
+        this.renderMessage(options.message, context.container);
+    }
+    updateMessage(message) {
+        this._renderedMessage?.remove();
+        const renderedMessage = this._register(this.markdownRendererService.render(typeof message === 'string' ? ( new MarkdownString(message)) : message, { asyncRenderCallback: () => this._onDidChangeHeight.fire() }));
+        this.renderMessage(renderedMessage.element, this._context.container);
+        this._renderedMessage = renderedMessage.element;
+    }
+};
+ChatConfirmationWidget = ( __decorate([
+    ( __param(2, IInstantiationService)),
+    ( __param(3, IMarkdownRendererService)),
+    ( __param(4, IContextMenuService)),
+    ( __param(5, IConfigurationService)),
+    ( __param(6, IContextKeyService)),
+    ( __param(7, IChatMarkdownAnchorService))
+], ChatConfirmationWidget));
+let ChatCustomConfirmationWidget = class ChatCustomConfirmationWidget extends BaseChatConfirmationWidget {
+    constructor(context, options, instantiationService, markdownRendererService, contextMenuService, configurationService, contextKeyService, chatMarkdownAnchorService) {
+        super(context, options, instantiationService, markdownRendererService, contextMenuService, configurationService, contextKeyService, chatMarkdownAnchorService);
+        this.renderMessage(options.message, context.container);
+    }
+};
+ChatCustomConfirmationWidget = ( __decorate([
+    ( __param(2, IInstantiationService)),
+    ( __param(3, IMarkdownRendererService)),
+    ( __param(4, IContextMenuService)),
+    ( __param(5, IConfigurationService)),
+    ( __param(6, IContextKeyService)),
+    ( __param(7, IChatMarkdownAnchorService))
+], ChatCustomConfirmationWidget));
+function configureAccessibilityContainer(container, title, message) {
+    container.tabIndex = 0;
+    const titleAsString = typeof title === 'string' ? title : title.value;
+    const messageAsString = typeof message === 'string' ? message : message && 'value' in message ? message.value : message && 'textContent' in message ? message.textContent : '';
+    container.setAttribute('aria-label', ( localize(5055, "Chat Confirmation Dialog {0} {1}", titleAsString, messageAsString)));
+    container.classList.add('chat-confirmation-widget-container');
+}
+
+export { ChatConfirmationWidget, ChatCustomConfirmationWidget, ChatQueryTitlePart, SimpleChatConfirmationWidget };

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

@@ -0,0 +1,20 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { IChatRendererDelegate } from "../chatListRenderer.js";
+import { ChatEditorOptions } from "../chatOptions.js";
+import { CodeBlockPart, CodeCompareBlockPart } from "../codeBlockPart.js";
+import { IDisposableReference } from "./chatCollections.js";
+export declare class EditorPool extends Disposable {
+    private readonly isSimpleWidget;
+    private readonly _pool;
+    inUse(): Iterable<CodeBlockPart>;
+    constructor(options: ChatEditorOptions, delegate: IChatRendererDelegate, overflowWidgetsDomNode: HTMLElement | undefined, isSimpleWidget: boolean | undefined, instantiationService: IInstantiationService);
+    get(): IDisposableReference<CodeBlockPart>;
+}
+export declare class DiffEditorPool extends Disposable {
+    private readonly isSimpleWidget;
+    private readonly _pool;
+    inUse(): Iterable<CodeCompareBlockPart>;
+    constructor(options: ChatEditorOptions, delegate: IChatRendererDelegate, overflowWidgetsDomNode: HTMLElement | undefined, isSimpleWidget: boolean | undefined, instantiationService: IInstantiationService);
+    get(): IDisposableReference<CodeCompareBlockPart>;
+}