@codingame/monaco-vscode-api 1.85.0 → 1.85.1

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

@@ -0,0 +1,583 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import * as dom from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { disposableTimeout } from 'monaco-editor/esm/vs/base/common/async.js';
+import { toErrorMessage } from 'monaco-editor/esm/vs/base/common/errorMessage.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { Disposable, DisposableStore, MutableDisposable, combinedDisposable, toDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { isEqual } from 'monaco-editor/esm/vs/base/common/resources.js';
+import { isDefined } from 'monaco-editor/esm/vs/base/common/types.js';
+import './media/chat.css.js';
+import { MenuId } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
+import { IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { IContextMenuService } from 'monaco-editor/esm/vs/platform/contextview/browser/contextView.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { ServiceCollection } from 'monaco-editor/esm/vs/platform/instantiation/common/serviceCollection.js';
+import { WorkbenchObjectTree } from 'monaco-editor/esm/vs/platform/list/browser/listService.js';
+import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { IViewsService } from '../../../common/views.js';
+import { IChatWidgetService, IChatAccessibilityService } from './chat.js';
+import { ChatInputPart } from './chatInputPart.js';
+import { ChatListDelegate, ChatListItemRenderer, ChatAccessibilityProvider } from './chatListRenderer.js';
+import { ChatEditorOptions } from './chatOptions.js';
+import { CONTEXT_IN_CHAT_SESSION, CONTEXT_CHAT_REQUEST_IN_PROGRESS, CONTEXT_RESPONSE_FILTERED } from '../common/chatContextKeys.js';
+import { IChatContributionService } from '../common/chatContributionService.js';
+import { ChatModelInitState } from '../common/chatModel.js';
+import { IChatService } from '../common/chatService.js';
+import { isResponseVM, isRequestVM, isWelcomeVM, ChatViewModel } from '../common/chatViewModel.js';
+var ChatWidget_1;
+const $ = dom.$;
+function revealLastElement(list) {
+    list.scrollTop = list.scrollHeight - list.renderHeight;
+}
+let ChatWidget = class ChatWidget extends Disposable {
+    static { ChatWidget_1 = this; }
+    static { this.CONTRIBS = []; }
+    get visible() {
+        return this._visible;
+    }
+    set viewModel(viewModel) {
+        if (this._viewModel === viewModel) {
+            return;
+        }
+        this.viewModelDisposables.clear();
+        this._viewModel = viewModel;
+        if (viewModel) {
+            this.viewModelDisposables.add(viewModel);
+        }
+        this._onDidChangeViewModel.fire();
+    }
+    get viewModel() {
+        return this._viewModel;
+    }
+    constructor(viewContext, viewOptions, styles, contextKeyService, instantiationService, chatService, chatWidgetService, contextMenuService, _chatAccessibilityService, _instantiationService, _logService) {
+        super();
+        this.viewContext = viewContext;
+        this.viewOptions = viewOptions;
+        this.styles = styles;
+        this.contextKeyService = contextKeyService;
+        this.instantiationService = instantiationService;
+        this.chatService = chatService;
+        this.contextMenuService = contextMenuService;
+        this._chatAccessibilityService = _chatAccessibilityService;
+        this._instantiationService = _instantiationService;
+        this._logService = _logService;
+        this._onDidFocus = this._register(( new Emitter()));
+        this.onDidFocus = this._onDidFocus.event;
+        this._onDidChangeViewModel = this._register(( new Emitter()));
+        this.onDidChangeViewModel = this._onDidChangeViewModel.event;
+        this._onDidClear = this._register(( new Emitter()));
+        this.onDidClear = this._onDidClear.event;
+        this._onDidAcceptInput = this._register(( new Emitter()));
+        this.onDidAcceptInput = this._onDidAcceptInput.event;
+        this._onDidChangeHeight = this._register(( new Emitter()));
+        this.onDidChangeHeight = this._onDidChangeHeight.event;
+        this.contribs = [];
+        this.visibleChangeCount = 0;
+        this._visible = false;
+        this.previousTreeScrollHeight = 0;
+        this.viewModelDisposables = this._register(( new DisposableStore()));
+        CONTEXT_IN_CHAT_SESSION.bindTo(contextKeyService).set(true);
+        this.requestInProgress = CONTEXT_CHAT_REQUEST_IN_PROGRESS.bindTo(contextKeyService);
+        this._register(chatWidgetService.register(this));
+    }
+    get supportsFileReferences() {
+        return !!this.viewOptions.supportsFileReferences;
+    }
+    get providerId() {
+        return this.viewModel?.providerId || '';
+    }
+    get inputEditor() {
+        return this.inputPart.inputEditor;
+    }
+    get inputUri() {
+        return this.inputPart.inputUri;
+    }
+    render(parent) {
+        const viewId = 'viewId' in this.viewContext ? this.viewContext.viewId : undefined;
+        this.editorOptions = this._register(this.instantiationService.createInstance(ChatEditorOptions, viewId, this.styles.listForeground, this.styles.inputEditorBackground, this.styles.resultEditorBackground));
+        const renderInputOnTop = this.viewOptions.renderInputOnTop ?? false;
+        const renderStyle = this.viewOptions.renderStyle;
+        this.container = dom.append(parent, $('.interactive-session'));
+        if (renderInputOnTop) {
+            this.createInput(this.container, { renderFollowups: false, renderStyle });
+            this.listContainer = dom.append(this.container, $(`.interactive-list`));
+        }
+        else {
+            this.listContainer = dom.append(this.container, $(`.interactive-list`));
+            this.createInput(this.container);
+        }
+        this.createList(this.listContainer, { renderStyle });
+        this._register(this.editorOptions.onDidChange(() => this.onDidStyleChange()));
+        this.onDidStyleChange();
+        if (this.viewModel) {
+            this.onDidChangeItems();
+            revealLastElement(this.tree);
+        }
+        this.contribs = ( ChatWidget_1.CONTRIBS.map(contrib => {
+            try {
+                return this._register(this.instantiationService.createInstance(contrib, this));
+            }
+            catch (err) {
+                this._logService.error('Failed to instantiate chat widget contrib', toErrorMessage(err));
+                return undefined;
+            }
+        })).filter(isDefined);
+    }
+    getContrib(id) {
+        return this.contribs.find(c => c.id === id);
+    }
+    focusInput() {
+        this.inputPart.focus();
+    }
+    hasInputFocus() {
+        return this.inputPart.hasFocus();
+    }
+    moveFocus(item, type) {
+        const items = this.viewModel?.getItems();
+        if (!items) {
+            return;
+        }
+        const responseItems = items.filter(i => isResponseVM(i));
+        const targetIndex = responseItems.indexOf(item);
+        if (targetIndex === undefined) {
+            return;
+        }
+        const indexToFocus = type === 'next' ? targetIndex + 1 : targetIndex - 1;
+        if (indexToFocus < 0 || indexToFocus > responseItems.length - 1) {
+            return;
+        }
+        this.focus(responseItems[indexToFocus]);
+    }
+    clear() {
+        if (this._dynamicMessageLayoutData) {
+            this._dynamicMessageLayoutData.enabled = true;
+        }
+        this._onDidClear.fire();
+    }
+    onDidChangeItems(skipDynamicLayout) {
+        if (this.tree && this._visible) {
+            const treeItems = ( (this.viewModel?.getItems() ?? [])
+                .map(item => {
+                return {
+                    element: item,
+                    collapsed: false,
+                    collapsible: false
+                };
+            }));
+            this.tree.setChildren(null, treeItems, {
+                diffIdentityProvider: {
+                    getId: (element) => {
+                        return ((isResponseVM(element) || isRequestVM(element)) ? element.dataId : element.id) +
+                            ((isWelcomeVM(element) && this.viewModel) ? `_${ChatModelInitState[this.viewModel.initState]}` : '') +
+                            `${(isRequestVM(element) || isWelcomeVM(element)) }` +
+                            `${isResponseVM(element) && element.renderData ? `_${this.visibleChangeCount}` : ''}` +
+                            (isResponseVM(element) ? `_${element.contentReferences.length}` : '');
+                    },
+                }
+            });
+            if (!skipDynamicLayout && this._dynamicMessageLayoutData) {
+                this.layoutDynamicChatTreeItemMode();
+            }
+            const lastItem = treeItems[treeItems.length - 1]?.element;
+            if (lastItem && isResponseVM(lastItem) && lastItem.isComplete) {
+                this.renderFollowups(lastItem.replyFollowups, lastItem);
+            }
+            else if (lastItem && isWelcomeVM(lastItem)) {
+                this.renderFollowups(lastItem.sampleQuestions);
+            }
+            else {
+                this.renderFollowups(undefined);
+            }
+        }
+    }
+    async renderFollowups(items, response) {
+        this.inputPart.renderFollowups(items, response);
+        if (this.bodyDimension) {
+            this.layout(this.bodyDimension.height, this.bodyDimension.width);
+        }
+    }
+    setVisible(visible) {
+        this._visible = visible;
+        this.visibleChangeCount++;
+        this.renderer.setVisible(visible);
+        if (visible) {
+            this._register(disposableTimeout(() => {
+                if (this._visible) {
+                    this.onDidChangeItems(true);
+                }
+            }, 0));
+        }
+    }
+    createList(listContainer, options) {
+        const scopedInstantiationService = this.instantiationService.createChild(( new ServiceCollection([IContextKeyService, this.contextKeyService])));
+        const delegate = scopedInstantiationService.createInstance(ChatListDelegate);
+        const rendererDelegate = {
+            getListLength: () => this.tree.getNode(null).visibleChildrenCount,
+        };
+        this.renderer = this._register(scopedInstantiationService.createInstance(ChatListItemRenderer, this.editorOptions, options, rendererDelegate));
+        this._register(this.renderer.onDidClickFollowup(item => {
+            this.acceptInput(item.message);
+        }));
+        this.tree = scopedInstantiationService.createInstance(WorkbenchObjectTree, 'Chat', listContainer, delegate, [this.renderer], {
+            identityProvider: { getId: (e) => e.id },
+            horizontalScrolling: false,
+            supportDynamicHeights: true,
+            hideTwistiesOfChildlessElements: true,
+            accessibilityProvider: this._instantiationService.createInstance(ChatAccessibilityProvider),
+            keyboardNavigationLabelProvider: { getKeyboardNavigationLabel: (e) => isRequestVM(e) ? e.message : isResponseVM(e) ? e.response.value : '' },
+            setRowLineHeight: false,
+            overrideStyles: {
+                listFocusBackground: this.styles.listBackground,
+                listInactiveFocusBackground: this.styles.listBackground,
+                listActiveSelectionBackground: this.styles.listBackground,
+                listFocusAndSelectionBackground: this.styles.listBackground,
+                listInactiveSelectionBackground: this.styles.listBackground,
+                listHoverBackground: this.styles.listBackground,
+                listBackground: this.styles.listBackground,
+                listFocusForeground: this.styles.listForeground,
+                listHoverForeground: this.styles.listForeground,
+                listInactiveFocusForeground: this.styles.listForeground,
+                listInactiveSelectionForeground: this.styles.listForeground,
+                listActiveSelectionForeground: this.styles.listForeground,
+                listFocusAndSelectionForeground: this.styles.listForeground,
+            }
+        });
+        this.tree.onContextMenu(e => this.onContextMenu(e));
+        this._register(this.tree.onDidChangeContentHeight(() => {
+            this.onDidChangeTreeContentHeight();
+        }));
+        this._register(this.renderer.onDidChangeItemHeight(e => {
+            this.tree.updateElementHeight(e.element, e.height);
+        }));
+        this._register(this.tree.onDidFocus(() => {
+            this._onDidFocus.fire();
+        }));
+    }
+    onContextMenu(e) {
+        e.browserEvent.preventDefault();
+        e.browserEvent.stopPropagation();
+        const selected = e.element;
+        const scopedContextKeyService = this.contextKeyService.createOverlay([
+            [CONTEXT_RESPONSE_FILTERED.key, isResponseVM(selected) && !!selected.errorDetails?.responseIsFiltered]
+        ]);
+        this.contextMenuService.showContextMenu({
+            menuId: MenuId.ChatContext,
+            menuActionOptions: { shouldForwardArgs: true },
+            contextKeyService: scopedContextKeyService,
+            getAnchor: () => e.anchor,
+            getActionsContext: () => selected,
+        });
+    }
+    onDidChangeTreeContentHeight() {
+        if (this.tree.scrollHeight !== this.previousTreeScrollHeight) {
+            const lastElementWasVisible = this.tree.scrollTop + this.tree.renderHeight >= this.previousTreeScrollHeight - 2;
+            if (lastElementWasVisible) {
+                dom.scheduleAtNextAnimationFrame(dom.getWindow(this.listContainer), () => {
+                    revealLastElement(this.tree);
+                }, 0);
+            }
+        }
+        this.previousTreeScrollHeight = this.tree.scrollHeight;
+    }
+    createInput(container, options) {
+        this.inputPart = this._register(this.instantiationService.createInstance(ChatInputPart, {
+            renderFollowups: options?.renderFollowups ?? true,
+            renderStyle: options?.renderStyle,
+        }));
+        this.inputPart.render(container, '', this);
+        this._register(this.inputPart.onDidLoadInputState(state => {
+            this.contribs.forEach(c => {
+                if (c.setInputState && typeof state === 'object' && state?.[c.id]) {
+                    c.setInputState(state[c.id]);
+                }
+            });
+        }));
+        this._register(this.inputPart.onDidFocus(() => this._onDidFocus.fire()));
+        this._register(this.inputPart.onDidAcceptFollowup(e => {
+            if (!this.viewModel) {
+                return;
+            }
+            this.acceptInput(e.followup.message);
+            if (!e.response) {
+                return;
+            }
+            this.chatService.notifyUserAction({
+                providerId: this.viewModel.providerId,
+                sessionId: this.viewModel.sessionId,
+                requestId: e.response.requestId,
+                agentId: e.response?.agent?.id,
+                action: {
+                    kind: 'followUp',
+                    followup: e.followup
+                },
+            });
+        }));
+        this._register(this.inputPart.onDidChangeHeight(() => this.bodyDimension && this.layout(this.bodyDimension.height, this.bodyDimension.width)));
+    }
+    onDidStyleChange() {
+        this.container.style.setProperty('--vscode-interactive-result-editor-background-color', this.editorOptions.configuration.resultEditor.backgroundColor?.toString() ?? '');
+        this.container.style.setProperty('--vscode-interactive-session-foreground', this.editorOptions.configuration.foreground?.toString() ?? '');
+    }
+    setModel(model, viewState) {
+        if (!this.container) {
+            throw new Error('Call render() before setModel()');
+        }
+        this.container.setAttribute('data-session-id', model.sessionId);
+        this.viewModel = this.instantiationService.createInstance(ChatViewModel, model);
+        this.viewModelDisposables.add(this.viewModel.onDidChange(e => {
+            this.requestInProgress.set(this.viewModel.requestInProgress);
+            this.onDidChangeItems();
+            if (e?.kind === 'addRequest') {
+                revealLastElement(this.tree);
+                this.focusInput();
+            }
+        }));
+        this.viewModelDisposables.add(this.viewModel.onDidDisposeModel(() => {
+            this.inputPart.saveState();
+            this.viewModel = undefined;
+            this.onDidChangeItems();
+        }));
+        this.inputPart.setState(model.providerId, viewState.inputValue);
+        this.contribs.forEach(c => {
+            if (c.setInputState && viewState.inputState?.[c.id]) {
+                c.setInputState(viewState.inputState?.[c.id]);
+            }
+        });
+        if (this.tree) {
+            this.onDidChangeItems();
+            revealLastElement(this.tree);
+        }
+    }
+    getFocus() {
+        return this.tree.getFocus()[0] ?? undefined;
+    }
+    reveal(item) {
+        this.tree.reveal(item);
+    }
+    focus(item) {
+        const items = this.tree.getNode(null).children;
+        const node = items.find(i => i.element?.id === item.id);
+        if (!node) {
+            return;
+        }
+        this.tree.setFocus([node.element]);
+        this.tree.domFocus();
+    }
+    setInputPlaceholder(placeholder) {
+        this.viewModel?.setInputPlaceholder(placeholder);
+    }
+    resetInputPlaceholder() {
+        this.viewModel?.resetInputPlaceholder();
+    }
+    updateInput(value = '') {
+        this.inputPart.setValue(value);
+    }
+    getInput() {
+        return this.inputPart.inputEditor.getValue();
+    }
+    async acceptInput(query) {
+        this._acceptInput(query ? { query } : undefined);
+    }
+    async acceptInputWithPrefix(prefix) {
+        this._acceptInput({ prefix });
+    }
+    collectInputState() {
+        const inputState = {};
+        this.contribs.forEach(c => {
+            if (c.getInputState) {
+                inputState[c.id] = c.getInputState();
+            }
+        });
+        return inputState;
+    }
+    async _acceptInput(opts) {
+        if (this.viewModel) {
+            this._onDidAcceptInput.fire();
+            const editorValue = this.getInput();
+            const requestId = this._chatAccessibilityService.acceptRequest();
+            const input = !opts ? editorValue :
+                'query' in opts ? opts.query :
+                    `${opts.prefix} ${editorValue}`;
+            const isUserQuery = !opts || 'query' in opts;
+            const result = await this.chatService.sendRequest(this.viewModel.sessionId, input);
+            if (result) {
+                const inputState = this.collectInputState();
+                this.inputPart.acceptInput(isUserQuery ? input : undefined, isUserQuery ? inputState : undefined);
+                result.responseCompletePromise.then(async () => {
+                    const responses = this.viewModel?.getItems().filter(isResponseVM);
+                    const lastResponse = responses?.[responses.length - 1];
+                    this._chatAccessibilityService.acceptResponse(lastResponse, requestId);
+                });
+            }
+            else {
+                this._chatAccessibilityService.acceptResponse(undefined, requestId);
+            }
+        }
+    }
+    getCodeBlockInfosForResponse(response) {
+        return this.renderer.getCodeBlockInfosForResponse(response);
+    }
+    getCodeBlockInfoForEditor(uri) {
+        return this.renderer.getCodeBlockInfoForEditor(uri);
+    }
+    getFileTreeInfosForResponse(response) {
+        return this.renderer.getFileTreeInfosForResponse(response);
+    }
+    getLastFocusedFileTreeForResponse(response) {
+        return this.renderer.getLastFocusedFileTreeForResponse(response);
+    }
+    focusLastMessage() {
+        if (!this.viewModel) {
+            return;
+        }
+        const items = this.tree.getNode(null).children;
+        const lastItem = items[items.length - 1];
+        if (!lastItem) {
+            return;
+        }
+        this.tree.setFocus([lastItem.element]);
+        this.tree.domFocus();
+    }
+    layout(height, width) {
+        width = Math.min(width, 850);
+        this.bodyDimension = new dom.Dimension(width, height);
+        const inputPartHeight = this.inputPart.layout(height, width);
+        const lastElementVisible = this.tree.scrollTop + this.tree.renderHeight >= this.tree.scrollHeight;
+        const listHeight = height - inputPartHeight;
+        this.tree.layout(listHeight, width);
+        this.tree.getHTMLElement().style.height = `${listHeight}px`;
+        this.renderer.layout(width);
+        if (lastElementVisible) {
+            revealLastElement(this.tree);
+        }
+        this.listContainer.style.height = `${height - inputPartHeight}px`;
+        this._onDidChangeHeight.fire(height);
+    }
+    setDynamicChatTreeItemLayout(numOfChatTreeItems, maxHeight) {
+        this._dynamicMessageLayoutData = { numOfMessages: numOfChatTreeItems, maxHeight, enabled: true };
+        this._register(this.renderer.onDidChangeItemHeight(() => this.layoutDynamicChatTreeItemMode()));
+        const mutableDisposable = this._register(( new MutableDisposable()));
+        this._register(this.tree.onDidScroll((e) => {
+            if (!this._dynamicMessageLayoutData?.enabled) {
+                return;
+            }
+            mutableDisposable.value = dom.scheduleAtNextAnimationFrame(dom.getWindow(this.listContainer), () => {
+                if (!e.scrollTopChanged || e.heightChanged || e.scrollHeightChanged) {
+                    return;
+                }
+                const renderHeight = e.height;
+                const diff = e.scrollHeight - renderHeight - e.scrollTop;
+                if (diff === 0) {
+                    return;
+                }
+                const possibleMaxHeight = (this._dynamicMessageLayoutData?.maxHeight ?? maxHeight);
+                const width = this.bodyDimension?.width ?? this.container.offsetWidth;
+                const inputPartHeight = this.inputPart.layout(possibleMaxHeight, width);
+                const newHeight = Math.min(renderHeight + diff, possibleMaxHeight - inputPartHeight);
+                this.layout(newHeight + inputPartHeight, width);
+            });
+        }));
+    }
+    updateDynamicChatTreeItemLayout(numOfChatTreeItems, maxHeight) {
+        this._dynamicMessageLayoutData = { numOfMessages: numOfChatTreeItems, maxHeight, enabled: true };
+        let hasChanged = false;
+        let height = this.bodyDimension.height;
+        let width = this.bodyDimension.width;
+        if (maxHeight < this.bodyDimension.height) {
+            height = maxHeight;
+            hasChanged = true;
+        }
+        const containerWidth = this.container.offsetWidth;
+        if (this.bodyDimension?.width !== containerWidth) {
+            width = containerWidth;
+            hasChanged = true;
+        }
+        if (hasChanged) {
+            this.layout(height, width);
+        }
+    }
+    get isDynamicChatTreeItemLayoutEnabled() {
+        return this._dynamicMessageLayoutData?.enabled ?? false;
+    }
+    set isDynamicChatTreeItemLayoutEnabled(value) {
+        if (!this._dynamicMessageLayoutData) {
+            return;
+        }
+        this._dynamicMessageLayoutData.enabled = value;
+    }
+    layoutDynamicChatTreeItemMode() {
+        if (!this.viewModel || !this._dynamicMessageLayoutData?.enabled) {
+            return;
+        }
+        const width = this.bodyDimension?.width ?? this.container.offsetWidth;
+        const inputHeight = this.inputPart.layout(this._dynamicMessageLayoutData.maxHeight, width);
+        const totalMessages = this.viewModel.getItems();
+        const messages = totalMessages.slice(-this._dynamicMessageLayoutData.numOfMessages);
+        const needsRerender = ( messages.some(m => m.currentRenderedHeight === undefined));
+        const listHeight = needsRerender
+            ? this._dynamicMessageLayoutData.maxHeight
+            : messages.reduce((acc, message) => acc + message.currentRenderedHeight, 0);
+        this.layout(Math.min(
+        inputHeight + listHeight + (totalMessages.length > 2 ? 18 : 0), this._dynamicMessageLayoutData.maxHeight), width);
+        if (needsRerender || !listHeight) {
+            revealLastElement(this.tree);
+        }
+    }
+    saveState() {
+        this.inputPart.saveState();
+    }
+    getViewState() {
+        this.inputPart.saveState();
+        return { inputValue: this.getInput(), inputState: this.collectInputState() };
+    }
+};
+ChatWidget = ChatWidget_1 = ( __decorate([
+    ( __param(3, IContextKeyService)),
+    ( __param(4, IInstantiationService)),
+    ( __param(5, IChatService)),
+    ( __param(6, IChatWidgetService)),
+    ( __param(7, IContextMenuService)),
+    ( __param(8, IChatAccessibilityService)),
+    ( __param(9, IInstantiationService)),
+    ( __param(10, ILogService))
+], ChatWidget));
+let ChatWidgetService = class ChatWidgetService {
+    get lastFocusedWidget() {
+        return this._lastFocusedWidget;
+    }
+    constructor(viewsService, chatContributionService) {
+        this.viewsService = viewsService;
+        this.chatContributionService = chatContributionService;
+        this._widgets = [];
+        this._lastFocusedWidget = undefined;
+    }
+    getWidgetByInputUri(uri) {
+        return this._widgets.find(w => isEqual(w.inputUri, uri));
+    }
+    getWidgetBySessionId(sessionId) {
+        return this._widgets.find(w => w.viewModel?.sessionId === sessionId);
+    }
+    async revealViewForProvider(providerId) {
+        const viewId = this.chatContributionService.getViewIdForProvider(providerId);
+        const view = await this.viewsService.openView(viewId);
+        return view?.widget;
+    }
+    setLastFocusedWidget(widget) {
+        if (widget === this._lastFocusedWidget) {
+            return;
+        }
+        this._lastFocusedWidget = widget;
+    }
+    register(newWidget) {
+        if (( this._widgets.some(widget => widget === newWidget))) {
+            throw new Error('Cannot register the same widget multiple times');
+        }
+        this._widgets.push(newWidget);
+        return combinedDisposable(newWidget.onDidFocus(() => this.setLastFocusedWidget(newWidget)), toDisposable(() => this._widgets.splice(this._widgets.indexOf(newWidget), 1)));
+    }
+};
+ChatWidgetService = ( __decorate([
+    ( __param(0, IViewsService)),
+    ( __param(1, IChatContributionService))
+], ChatWidgetService));
+export { ChatWidget, ChatWidgetService };

package/vscode/src/vs/workbench/contrib/chat/browser/codeBlockPart.css.js

@@ -0,0 +1,4 @@
+import n from '../../../../../../../external/rollup-plugin-styles/dist/runtime/inject-css.js';
+var css = ".interactive-result-code-block{position:relative}.interactive-result-code-block .monaco-toolbar{background-color:var(--vscode-interactive-result-editor-background-color,var(--vscode-editor-background));border:1px solid var(--vscode-chat-requestBorder);display:none;height:26px;position:absolute;right:10px;top:-13px;z-index:100}.interactive-result-code-block .monaco-toolbar .action-item{height:24px;margin:1px 2px;width:24px}.interactive-result-code-block .monaco-toolbar .action-item .codicon{margin:1px}.interactive-result-code-block .monaco-toolbar:focus-within,.interactive-result-code-block.focused .monaco-toolbar,.interactive-result-code-block:hover .monaco-toolbar{border-radius:2px;display:initial}.interactive-result-code-block .interactive-result-code-block-toolbar.force-visibility .monaco-toolbar{display:initial!important}.interactive-result-code-block{background-color:var(--vscode-interactive-result-editor-background-color);border:1px solid var(--vscode-input-border,transparent);margin:16px 0}.interactive-result-code-block:has(.monaco-editor.focused){border-color:var(--vscode-focusBorder,transparent)}.interactive-result-code-block,.interactive-result-code-block .monaco-editor,.interactive-result-code-block .monaco-editor .overflow-guard{border-radius:4px}.interactive-result-code-block .interactive-result-vulns{font-size:.9em;padding:0 8px 2px}.interactive-result-code-block .interactive-result-vulns-header{display:flex;height:22px}.interactive-result-code-block .interactive-result-vulns-header,.interactive-result-code-block .interactive-result-vulns-list{opacity:.8}.interactive-result-code-block .interactive-result-vulns-list{margin:0;padding-bottom:3px;padding-left:16px!important}.interactive-result-code-block.chat-vulnerabilities-collapsed .interactive-result-vulns-list{display:none}.interactive-result-code-block .interactive-result-vulns-list .chat-vuln-title{font-weight:700}.interactive-result-code-block.no-vulns .interactive-result-vulns{display:none}.interactive-result-code-block .interactive-result-vulns-header .monaco-button{border:none;color:var(--vscode-foreground)!important;display:inline-flex;justify-content:normal;padding:0;text-align:initial;user-select:none;width:100%}.interactive-result-code-block .interactive-result-vulns-header .monaco-text-button:focus{outline:none}.interactive-result-code-block .interactive-result-vulns-header .monaco-text-button:focus-visible{outline:1px solid var(--vscode-focusBorder)}";
+n(css,{});
+export { css, css as default };