@codingame/monaco-vscode-api 1.78.8 → 1.79.0

package/dist/vscode/vs/workbench/contrib/interactiveSession/browser/interactiveSessionOptions.js

@@ -0,0 +1,77 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { IThemeService } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
+import { IViewDescriptorService } from '../../../common/views.js';
+let InteractiveSessionEditorOptions = class InteractiveSessionEditorOptions extends Disposable {
+    get configuration() {
+        return this._config;
+    }
+    constructor(viewId, inputEditorBackgroundColorDelegate, resultEditorBackgroundColorDelegate, configurationService, themeService, viewDescriptorService) {
+        super();
+        this.inputEditorBackgroundColorDelegate = inputEditorBackgroundColorDelegate;
+        this.resultEditorBackgroundColorDelegate = resultEditorBackgroundColorDelegate;
+        this.configurationService = configurationService;
+        this.themeService = themeService;
+        this.viewDescriptorService = viewDescriptorService;
+        this._onDidChange = this._register(( new Emitter()));
+        this.onDidChange = this._onDidChange.event;
+        this._register(this.themeService.onDidColorThemeChange(e => this.update()));
+        this._register(this.viewDescriptorService.onDidChangeLocation(e => {
+            if (( e.views.some(v => v.id === viewId))) {
+                this.update();
+            }
+        }));
+        this._register(this.configurationService.onDidChangeConfiguration(e => {
+            if (( InteractiveSessionEditorOptions.relevantSettingIds.some(id => e.affectsConfiguration(id)))) {
+                this.update();
+            }
+        }));
+        this.update();
+    }
+    update() {
+        const editorConfig = this.configurationService.getValue('editor');
+        const interactiveSessionEditorConfig = this.configurationService.getValue('interactiveSession').editor;
+        const accessibilitySupport = this.configurationService.getValue('editor.accessibilitySupport');
+        this._config = {
+            inputEditor: {
+                backgroundColor: this.themeService.getColorTheme().getColor(this.inputEditorBackgroundColorDelegate()),
+                accessibilitySupport,
+            },
+            resultEditor: {
+                backgroundColor: this.themeService.getColorTheme().getColor(this.resultEditorBackgroundColorDelegate()),
+                fontSize: interactiveSessionEditorConfig.fontSize,
+                fontFamily: interactiveSessionEditorConfig.fontFamily === 'default' ? editorConfig.fontFamily : interactiveSessionEditorConfig.fontFamily,
+                fontWeight: interactiveSessionEditorConfig.fontWeight,
+                lineHeight: interactiveSessionEditorConfig.lineHeight ? interactiveSessionEditorConfig.lineHeight : InteractiveSessionEditorOptions.lineHeightEm * interactiveSessionEditorConfig.fontSize,
+                bracketPairColorization: {
+                    enabled: this.configurationService.getValue('editor.bracketPairColorization.enabled'),
+                    independentColorPoolPerBracketType: this.configurationService.getValue('editor.bracketPairColorization.independentColorPoolPerBracketType'),
+                },
+                wordWrap: interactiveSessionEditorConfig.wordWrap,
+                fontLigatures: editorConfig.fontLigatures,
+            }
+        };
+        this._onDidChange.fire();
+    }
+};
+InteractiveSessionEditorOptions.lineHeightEm = 1.4;
+InteractiveSessionEditorOptions.relevantSettingIds = [
+    'interactiveSession.editor.lineHeight',
+    'interactiveSession.editor.fontSize',
+    'interactiveSession.editor.fontFamily',
+    'interactiveSession.editor.fontWeight',
+    'interactiveSession.editor.wordWrap',
+    'editor.cursorBlinking',
+    'editor.fontLigatures',
+    'editor.accessibilitySupport',
+    'editor.bracketPairColorization.enabled',
+    'editor.bracketPairColorization.independentColorPoolPerBracketType',
+];
+InteractiveSessionEditorOptions = ( __decorate([
+    ( __param(3, IConfigurationService)),
+    ( __param(4, IThemeService)),
+    ( __param(5, IViewDescriptorService))
+], InteractiveSessionEditorOptions));
+export { InteractiveSessionEditorOptions };

package/dist/vscode/vs/workbench/contrib/interactiveSession/browser/interactiveSessionWidget.js

@@ -0,0 +1,311 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import * as dom from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { CancellationToken } from 'monaco-editor/esm/vs/base/common/cancellation.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { Disposable, DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import "../../../../../../assets/interactiveSession.css";
+import { localize } from 'monaco-editor/esm/vs/nls.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 { createDecorator, 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 { foreground } from 'monaco-editor/esm/vs/platform/theme/common/colorRegistry.js';
+import { InteractiveSessionInputPart } from './interactiveSessionInputPart.js';
+import { InteractiveSessionListDelegate, InteractiveListItemRenderer, InteractiveSessionAccessibilityProvider } from './interactiveSessionListRenderer.js';
+import { InteractiveSessionEditorOptions } from './interactiveSessionOptions.js';
+import { CONTEXT_IN_INTERACTIVE_SESSION, CONTEXT_INTERACTIVE_REQUEST_IN_PROGRESS } from '../common/interactiveSessionContextKeys.js';
+import { IInteractiveSessionService } from '../common/interactiveSessionService.js';
+import { isRequestVM, isWelcomeVM, isResponseVM, InteractiveSessionViewModel } from '../common/interactiveSessionViewModel.js';
+const IInteractiveSessionWidgetService = ( createDecorator('interactiveSessionWidgetService'));
+const $ = dom.$;
+function revealLastElement(list) {
+    list.scrollTop = list.scrollHeight - list.renderHeight;
+}
+let InteractiveSessionWidget = class InteractiveSessionWidget extends Disposable {
+    set viewModel(viewModel) {
+        if (this._viewModel === viewModel) {
+            return;
+        }
+        this.viewModelDisposables.clear();
+        this._viewModel = viewModel;
+        if (viewModel) {
+            this.viewModelDisposables.add(viewModel);
+        }
+        this.slashCommandsPromise = undefined;
+        this.lastSlashCommands = undefined;
+        this.getSlashCommands().then(() => {
+            this.onDidChangeItems();
+        });
+        this._onDidChangeViewModel.fire();
+    }
+    get viewModel() {
+        return this._viewModel;
+    }
+    constructor(viewContext, listBackgroundColorDelegate, inputEditorBackgroundColorDelegate, resultEditorBackgroundColorDelegate, contextKeyService, instantiationService, interactiveSessionService, interactiveSessionWidgetService, contextMenuService) {
+        super();
+        this.viewContext = viewContext;
+        this.listBackgroundColorDelegate = listBackgroundColorDelegate;
+        this.inputEditorBackgroundColorDelegate = inputEditorBackgroundColorDelegate;
+        this.resultEditorBackgroundColorDelegate = resultEditorBackgroundColorDelegate;
+        this.contextKeyService = contextKeyService;
+        this.instantiationService = instantiationService;
+        this.interactiveSessionService = interactiveSessionService;
+        this.contextMenuService = contextMenuService;
+        this._onDidFocus = this._register(( new Emitter()));
+        this.onDidFocus = this._onDidFocus.event;
+        this._onDidChangeViewModel = this._register(( new Emitter()));
+        this.onDidChangeViewModel = this._onDidChangeViewModel.event;
+        this.visible = false;
+        this.visibleChangeCount = 0;
+        this.previousTreeScrollHeight = 0;
+        this.viewModelDisposables = ( new DisposableStore());
+        CONTEXT_IN_INTERACTIVE_SESSION.bindTo(contextKeyService).set(true);
+        this.requestInProgress = CONTEXT_INTERACTIVE_REQUEST_IN_PROGRESS.bindTo(contextKeyService);
+        this._register(interactiveSessionWidgetService.register(this));
+    }
+    get providerId() {
+        return this.viewModel?.providerId || '';
+    }
+    get inputEditor() {
+        return this.inputPart.inputEditor;
+    }
+    get inputUri() {
+        return this.inputPart.inputUri;
+    }
+    render(parent) {
+        this.container = dom.append(parent, $('.interactive-session'));
+        this.listContainer = dom.append(this.container, $(`.interactive-list`));
+        const viewId = 'viewId' in this.viewContext ? this.viewContext.viewId : undefined;
+        this.editorOptions = this._register(this.instantiationService.createInstance(InteractiveSessionEditorOptions, viewId, this.inputEditorBackgroundColorDelegate, this.resultEditorBackgroundColorDelegate));
+        this.createList(this.listContainer);
+        this.createInput(this.container);
+        this._register(this.editorOptions.onDidChange(() => this.onDidStyleChange()));
+        this.onDidStyleChange();
+        if (this.viewModel) {
+            this.onDidChangeItems();
+            revealLastElement(this.tree);
+        }
+        InteractiveSessionWidget.CONTRIBS.forEach(contrib => this._register(this.instantiationService.createInstance(contrib, this)));
+    }
+    focusInput() {
+        this.inputPart.focus();
+    }
+    onDidChangeItems() {
+        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 element.id +
+                            `${(isRequestVM(element) || isWelcomeVM(element)) && !!this.lastSlashCommands ? '_scLoaded' : ''}` +
+                            `${isResponseVM(element) && element.renderData ? `_${this.visibleChangeCount}` : ''}`;
+                    },
+                }
+            });
+            const lastItem = treeItems[treeItems.length - 1]?.element;
+            if (lastItem && isResponseVM(lastItem) && lastItem.isComplete) {
+                this.renderFollowups(lastItem.replyFollowups);
+            }
+            else {
+                this.renderFollowups(undefined);
+            }
+        }
+    }
+    async renderFollowups(items) {
+        this.inputPart.renderFollowups(items);
+        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.onDidChangeItems();
+        }
+    }
+    async getSlashCommands() {
+        if (!this.viewModel) {
+            return;
+        }
+        if (!this.slashCommandsPromise) {
+            this.slashCommandsPromise = this.interactiveSessionService.getSlashCommands(this.viewModel.sessionId, CancellationToken.None).then(commands => {
+                const clearCommand = {
+                    command: 'clear',
+                    sortText: 'z_clear',
+                    detail: ( localize('clear', "Clear the session")),
+                };
+                this.lastSlashCommands = [
+                    ...(commands ?? []),
+                    clearCommand
+                ];
+                return this.lastSlashCommands;
+            });
+        }
+        return this.slashCommandsPromise;
+    }
+    createList(listContainer) {
+        const scopedInstantiationService = this.instantiationService.createChild(( new ServiceCollection([IContextKeyService, this.contextKeyService])));
+        const delegate = scopedInstantiationService.createInstance(InteractiveSessionListDelegate);
+        const rendererDelegate = {
+            getListLength: () => this.tree.getNode(null).visibleChildrenCount,
+            getSlashCommands: () => this.lastSlashCommands ?? [],
+        };
+        this.renderer = this._register(scopedInstantiationService.createInstance(InteractiveListItemRenderer, this.editorOptions, rendererDelegate));
+        this._register(this.renderer.onDidClickFollowup(item => {
+            this.acceptInput(item);
+        }));
+        this.tree = scopedInstantiationService.createInstance(WorkbenchObjectTree, 'InteractiveSession', listContainer, delegate, [this.renderer], {
+            identityProvider: { getId: (e) => e.id },
+            supportDynamicHeights: true,
+            hideTwistiesOfChildlessElements: true,
+            accessibilityProvider: ( new InteractiveSessionAccessibilityProvider()),
+            keyboardNavigationLabelProvider: { getKeyboardNavigationLabel: (e) => isRequestVM(e) ? e.message : isResponseVM(e) ? e.response.value : '' },
+            setRowLineHeight: false,
+            overrideStyles: {
+                listFocusBackground: this.listBackgroundColorDelegate(),
+                listInactiveFocusBackground: this.listBackgroundColorDelegate(),
+                listActiveSelectionBackground: this.listBackgroundColorDelegate(),
+                listFocusAndSelectionBackground: this.listBackgroundColorDelegate(),
+                listInactiveSelectionBackground: this.listBackgroundColorDelegate(),
+                listHoverBackground: this.listBackgroundColorDelegate(),
+                listBackground: this.listBackgroundColorDelegate(),
+                listFocusForeground: foreground,
+                listHoverForeground: foreground,
+                listInactiveFocusForeground: foreground,
+                listInactiveSelectionForeground: foreground,
+                listActiveSelectionForeground: foreground,
+                listFocusAndSelectionForeground: foreground,
+            }
+        });
+        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();
+        this.contextMenuService.showContextMenu({
+            menuId: MenuId.InteractiveSessionContext,
+            menuActionOptions: { shouldForwardArgs: true },
+            contextKeyService: this.contextKeyService,
+            getAnchor: () => e.anchor,
+            getActionsContext: () => e.element,
+        });
+    }
+    onDidChangeTreeContentHeight() {
+        if (this.tree.scrollHeight !== this.previousTreeScrollHeight) {
+            const lastElementWasVisible = this.tree.scrollTop + this.tree.renderHeight >= this.previousTreeScrollHeight - 2;
+            if (lastElementWasVisible) {
+                dom.scheduleAtNextAnimationFrame(() => {
+                    revealLastElement(this.tree);
+                }, 0);
+            }
+        }
+        this.previousTreeScrollHeight = this.tree.scrollHeight;
+    }
+    createInput(container) {
+        this.inputPart = this.instantiationService.createInstance(InteractiveSessionInputPart);
+        this.inputPart.render(container, '', this);
+        this._register(this.inputPart.onDidFocus(() => this._onDidFocus.fire()));
+        this._register(this.inputPart.onDidAcceptFollowup(followup => this.acceptInput(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() ?? '');
+    }
+    setModel(model, viewState) {
+        if (!this.container) {
+            throw new Error('Call render() before setModel()');
+        }
+        this.viewModel = this.instantiationService.createInstance(InteractiveSessionViewModel, model);
+        this.viewModelDisposables.add(this.viewModel.onDidChange(() => {
+            this.slashCommandsPromise = undefined;
+            this.requestInProgress.set(this.viewModel.requestInProgress);
+            this.onDidChangeItems();
+        }));
+        this.viewModelDisposables.add(this.viewModel.onDidDisposeModel(() => {
+            this.viewModel = undefined;
+            this.onDidChangeItems();
+        }));
+        this.inputPart.setState(model.providerId, viewState.inputValue ?? '');
+        if (this.tree) {
+            this.onDidChangeItems();
+            revealLastElement(this.tree);
+        }
+    }
+    async acceptInput(query) {
+        if (this.viewModel) {
+            const editorValue = this.inputPart.inputEditor.getValue();
+            if (!query && editorValue.trim() === '/clear') {
+                this.interactiveSessionService.clearSession(this.viewModel.sessionId);
+                this.inputPart.inputEditor.setValue('');
+                return;
+            }
+            const input = query ?? editorValue;
+            const result = await this.interactiveSessionService.sendRequest(this.viewModel.sessionId, input);
+            if (result) {
+                revealLastElement(this.tree);
+                this.inputPart.acceptInput(query);
+            }
+        }
+    }
+    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) {
+        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`;
+    }
+    saveState() {
+        this.inputPart.saveState();
+    }
+    getViewState() {
+        this.inputPart.saveState();
+        return { inputValue: this.inputPart.inputEditor.getValue() };
+    }
+};
+InteractiveSessionWidget.CONTRIBS = [];
+InteractiveSessionWidget = ( __decorate([
+    ( __param(4, IContextKeyService)),
+    ( __param(5, IInstantiationService)),
+    ( __param(6, IInteractiveSessionService)),
+    ( __param(7, IInteractiveSessionWidgetService)),
+    ( __param(8, IContextMenuService))
+], InteractiveSessionWidget));
+export { IInteractiveSessionWidgetService, InteractiveSessionWidget };

package/dist/vscode/vs/workbench/contrib/interactiveSession/common/interactiveSessionContextKeys.js

@@ -0,0 +1,48 @@
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { RawContextKey } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+const CONTEXT_RESPONSE_HAS_PROVIDER_ID = ( new RawContextKey(
+ 'interactiveSessionResponseHasProviderId',
+ false,
+ { type: 'boolean', description: ( localize(
+  'interactiveSessionResponseHasProviderId',
+  "True when the provider has assigned an id to this response."
+ )) }
+));
+const CONTEXT_RESPONSE_VOTE = ( new RawContextKey(
+ 'interactiveSessionResponseVote',
+ '',
+ { type: 'string', description: ( localize(
+  'interactiveSessionResponseVote',
+  "When the response has been voted up, is set to 'up'. When voted down, is set to 'down'. Otherwise an empty string."
+ )) }
+));
+const CONTEXT_INTERACTIVE_REQUEST_IN_PROGRESS = ( new RawContextKey(
+ 'interactiveSessionRequestInProgress',
+ false,
+ { type: 'boolean', description: ( localize(
+  'interactiveSessionRequestInProgress',
+  "True when the current request is still in progress."
+ )) }
+));
+const CONTEXT_INTERACTIVE_INPUT_HAS_TEXT = ( new RawContextKey(
+ 'interactiveInputHasText',
+ false,
+ { type: 'boolean', description: ( localize('interactiveInputHasText', "True when the interactive input has text.")) }
+));
+const CONTEXT_IN_INTERACTIVE_INPUT = ( new RawContextKey(
+ 'inInteractiveInput',
+ false,
+ { type: 'boolean', description: ( localize(
+  'inInteractiveInput',
+  "True when focus is in the interactive input, false otherwise."
+ )) }
+));
+const CONTEXT_IN_INTERACTIVE_SESSION = ( new RawContextKey(
+ 'inInteractiveSession',
+ false,
+ { type: 'boolean', description: ( localize(
+  'inInteractiveSession',
+  "True when focus is in the interactive session widget, false otherwise."
+ )) }
+));
+export { CONTEXT_INTERACTIVE_INPUT_HAS_TEXT, CONTEXT_INTERACTIVE_REQUEST_IN_PROGRESS, CONTEXT_IN_INTERACTIVE_INPUT, CONTEXT_IN_INTERACTIVE_SESSION, CONTEXT_RESPONSE_HAS_PROVIDER_ID, CONTEXT_RESPONSE_VOTE };

package/dist/vscode/vs/workbench/contrib/interactiveSession/common/interactiveSessionService.js

@@ -0,0 +1,8 @@
+import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+var InteractiveSessionVoteDirection;
+( (function(InteractiveSessionVoteDirection) {
+    InteractiveSessionVoteDirection[InteractiveSessionVoteDirection["Up"] = 1] = "Up";
+    InteractiveSessionVoteDirection[InteractiveSessionVoteDirection["Down"] = 2] = "Down";
+})(InteractiveSessionVoteDirection || (InteractiveSessionVoteDirection = {})));
+const IInteractiveSessionService = ( createDecorator('IInteractiveSessionService'));
+export { IInteractiveSessionService, InteractiveSessionVoteDirection };

package/dist/vscode/vs/workbench/contrib/interactiveSession/common/interactiveSessionViewModel.js

@@ -0,0 +1,207 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { MarkdownString } from 'monaco-editor/esm/vs/base/common/htmlContent.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { countWords } from './interactiveSessionWordCounter.js';
+function isRequestVM(item) {
+    return !!item && typeof item === 'object' && 'message' in item;
+}
+function isResponseVM(item) {
+    return !!item && typeof item.onDidChange !== 'undefined';
+}
+function isWelcomeVM(item) {
+    return !!item && typeof item === 'object' && 'content' in item;
+}
+let InteractiveSessionViewModel = class InteractiveSessionViewModel extends Disposable {
+    get inputPlaceholder() {
+        return this._model.inputPlaceholder;
+    }
+    get sessionId() {
+        return this._model.sessionId;
+    }
+    get requestInProgress() {
+        return this._model.requestInProgress;
+    }
+    get providerId() {
+        return this._model.providerId;
+    }
+    constructor(_model, instantiationService) {
+        super();
+        this._model = _model;
+        this.instantiationService = instantiationService;
+        this._onDidDisposeModel = this._register(( new Emitter()));
+        this.onDidDisposeModel = this._onDidDisposeModel.event;
+        this._onDidChange = this._register(( new Emitter()));
+        this.onDidChange = this._onDidChange.event;
+        this._items = [];
+        _model.getRequests().forEach((request, i) => {
+            this._items.push(( new InteractiveRequestViewModel(request)));
+            if (request.response) {
+                this.onAddResponse(request.response);
+            }
+        });
+        this._register(_model.onDidDispose(() => this._onDidDisposeModel.fire()));
+        this._register(_model.onDidChange(e => {
+            if (e.kind === 'addRequest') {
+                this._items.push(( new InteractiveRequestViewModel(e.request)));
+                if (e.request.response) {
+                    this.onAddResponse(e.request.response);
+                }
+            }
+            else if (e.kind === 'addResponse') {
+                this.onAddResponse(e.response);
+            }
+            this._onDidChange.fire();
+        }));
+    }
+    onAddResponse(responseModel) {
+        const response = this.instantiationService.createInstance(InteractiveResponseViewModel, responseModel);
+        this._register(response.onDidChange(() => this._onDidChange.fire()));
+        this._items.push(response);
+    }
+    getItems() {
+        return [...(this._model.welcomeMessage ? [this._model.welcomeMessage] : []), ...this._items];
+    }
+    dispose() {
+        super.dispose();
+        this._items
+            .filter((item) => item instanceof InteractiveResponseViewModel)
+            .forEach((item) => item.dispose());
+    }
+};
+InteractiveSessionViewModel = ( __decorate([
+    ( __param(1, IInstantiationService))
+], InteractiveSessionViewModel));
+class InteractiveRequestViewModel {
+    get id() {
+        return this._model.id;
+    }
+    get username() {
+        return this._model.username;
+    }
+    get avatarIconUri() {
+        return this._model.avatarIconUri;
+    }
+    get message() {
+        return this._model.message;
+    }
+    get messageText() {
+        return typeof this.message === 'string' ? this.message : this.message.message;
+    }
+    constructor(_model) {
+        this._model = _model;
+    }
+}
+let InteractiveResponseViewModel = class InteractiveResponseViewModel extends Disposable {
+    get id() {
+        return this._model.id + `_${this._modelChangeCount}`;
+    }
+    get providerId() {
+        return this._model.providerId;
+    }
+    get providerResponseId() {
+        return this._model.providerResponseId;
+    }
+    get username() {
+        return this._model.username;
+    }
+    get avatarIconUri() {
+        return this._model.avatarIconUri;
+    }
+    get response() {
+        if (this._isPlaceholder) {
+            return ( new MarkdownString(( localize('thinking', "Thinking")) + '\u2026'));
+        }
+        return this._model.response;
+    }
+    get isComplete() {
+        return this._model.isComplete;
+    }
+    get isCanceled() {
+        return this._model.isCanceled;
+    }
+    get isPlaceholder() {
+        return this._isPlaceholder;
+    }
+    get replyFollowups() {
+        return this._model.followups?.filter((f) => f.kind === 'reply');
+    }
+    get commandFollowups() {
+        return this._model.followups?.filter((f) => f.kind === 'command');
+    }
+    get errorDetails() {
+        return this._model.errorDetails;
+    }
+    get vote() {
+        return this._model.vote;
+    }
+    get contentUpdateTimings() {
+        return this._contentUpdateTimings;
+    }
+    constructor(_model, logService) {
+        super();
+        this._model = _model;
+        this.logService = logService;
+        this._modelChangeCount = 0;
+        this._onDidChange = this._register(( new Emitter()));
+        this.onDidChange = this._onDidChange.event;
+        this._isPlaceholder = false;
+        this.renderData = undefined;
+        this._contentUpdateTimings = undefined;
+        this._isPlaceholder = !_model.response.value && !_model.isComplete;
+        if (!_model.isComplete) {
+            this._contentUpdateTimings = {
+                loadingStartTime: Date.now(),
+                lastUpdateTime: Date.now(),
+                wordCountAfterLastUpdate: this._isPlaceholder ? 0 : countWords(_model.response.value),
+                impliedWordLoadRate: 0
+            };
+        }
+        this._register(_model.onDidChange(() => {
+            if (this._isPlaceholder && (_model.response.value || this.isComplete)) {
+                this._isPlaceholder = false;
+            }
+            if (this._contentUpdateTimings) {
+                const now = Date.now();
+                const wordCount = countWords(_model.response.value);
+                const timeDiff = now - this._contentUpdateTimings.loadingStartTime;
+                const impliedWordLoadRate = wordCount / (timeDiff / 1000);
+                if (!this.isComplete) {
+                    this.trace('onDidChange', `Update- got ${wordCount} words over ${timeDiff}ms = ${impliedWordLoadRate} words/s. ${this.renderData?.renderedWordCount} words are rendered.`);
+                    this._contentUpdateTimings = {
+                        loadingStartTime: this._contentUpdateTimings.loadingStartTime,
+                        lastUpdateTime: now,
+                        wordCountAfterLastUpdate: wordCount,
+                        impliedWordLoadRate
+                    };
+                }
+                else {
+                    this.trace(`onDidChange`, `Done- got ${wordCount} words over ${timeDiff}ms = ${impliedWordLoadRate} words/s. ${this.renderData?.renderedWordCount} words are rendered.`);
+                }
+            }
+            else {
+                this.logService.warn('InteractiveResponseViewModel#onDidChange: got model update but contentUpdateTimings is not initialized');
+            }
+            this._modelChangeCount++;
+            if (this.renderData) {
+                this.renderData.isFullyRendered = false;
+                this.renderData.lastRenderTime = Date.now();
+            }
+            this._onDidChange.fire();
+        }));
+    }
+    trace(tag, message) {
+        this.logService.trace(`InteractiveResponseViewModel#${tag}: ${message}`);
+    }
+    setVote(vote) {
+        this._modelChangeCount++;
+        this._model.setVote(vote);
+    }
+};
+InteractiveResponseViewModel = ( __decorate([
+    ( __param(1, ILogService))
+], InteractiveResponseViewModel));
+export { InteractiveRequestViewModel, InteractiveResponseViewModel, InteractiveSessionViewModel, isRequestVM, isResponseVM, isWelcomeVM };

package/dist/vscode/vs/workbench/contrib/interactiveSession/common/interactiveSessionWidgetHistoryService.js

@@ -0,0 +1,3 @@
+import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+const IInteractiveSessionWidgetHistoryService = ( createDecorator('IInteractiveSessionWidgetHistoryService'));
+export { IInteractiveSessionWidgetHistoryService };