@codingame/monaco-vscode-api 3.2.3 → 4.1.0

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

@@ -1,14 +1,13 @@
 import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
 import { $ } from '../../../../base/browser/dom.js';
 import { toErrorMessage } from '../../../../base/common/errorMessage.js';
-import { MarkdownString } from '../../../../base/common/htmlContent.js';
 import { revive } from '../../../../base/common/marshalling.js';
-import { basename } from '../../../../base/common/resources.js';
 import { URI } from '../../../../base/common/uri.js';
 import { IKeybindingService } from '../../../../platform/keybinding/common/keybinding.js';
 import { ILabelService } from '../../../../platform/label/common/label.js';
 import { ILogService } from '../../../../platform/log/common/log.js';
-import { ChatRequestTextPart, ChatRequestDynamicVariablePart } from '../common/chatParserTypes.js';
+import { ChatRequestTextPart, ChatRequestDynamicVariablePart, ChatRequestAgentPart } from '../common/chatParserTypes.js';
+import { contentRefUrl } from '../common/annotations.js';
 const variableRefUrl = 'http://_vscodedecoration_';
 let ChatMarkdownDecorationsRenderer = class ChatMarkdownDecorationsRenderer {
     constructor(keybindingService, labelService, logService) {
@@ -25,7 +24,9 @@ let ChatMarkdownDecorationsRenderer = class ChatMarkdownDecorationsRenderer {
             else {
                 const uri = part instanceof ChatRequestDynamicVariablePart && ( part.data.map(d => d.value)).find((d) => d instanceof URI)
                     || undefined;
-                const title = uri ? encodeURIComponent(this.labelService.getUriLabel(uri, { relative: true })) : '';
+                const title = uri ? encodeURIComponent(this.labelService.getUriLabel(uri, { relative: true })) :
+                    part instanceof ChatRequestAgentPart ? part.agent.id :
+                        '';
                 result += `[${part.text}](${variableRefUrl}?${title})`;
             }
         }
@@ -94,74 +95,4 @@ ChatMarkdownDecorationsRenderer = ( __decorate([
     ( __param(1, ILabelService)),
     ( __param(2, ILogService))
 ], ChatMarkdownDecorationsRenderer));
-function extractVulnerabilitiesFromText(text) {
-    const vulnerabilities = [];
-    let newText = text;
-    let match;
-    while ((match = /<vscode_annotation details="(.*?)">(.*?)<\/vscode_annotation>/ms.exec(newText)) !== null) {
-        const [full, details, content] = match;
-        const start = match.index;
-        const textBefore = newText.substring(0, start);
-        const linesBefore = textBefore.split('\n').length - 1;
-        const linesInside = content.split('\n').length - 1;
-        const previousNewlineIdx = textBefore.lastIndexOf('\n');
-        const startColumn = start - (previousNewlineIdx + 1) + 1;
-        const endPreviousNewlineIdx = (textBefore + content).lastIndexOf('\n');
-        const endColumn = start + content.length - (endPreviousNewlineIdx + 1) + 1;
-        try {
-            const vulnDetails = JSON.parse(decodeURIComponent(details));
-            vulnDetails.forEach(({ title, description }) => vulnerabilities.push({
-                title, description, range: { startLineNumber: linesBefore + 1, startColumn, endLineNumber: linesBefore + linesInside + 1, endColumn }
-            }));
-        }
-        catch (err) {
-        }
-        newText = newText.substring(0, start) + content + newText.substring(start + full.length);
-    }
-    return { newText, vulnerabilities };
-}
-const contentRefUrl = 'http://_vscodecontentref_';
-function annotateSpecialMarkdownContent(response) {
-    const result = [];
-    for (const item of response) {
-        const previousItem = result[result.length - 1];
-        if (item.kind === 'inlineReference') {
-            const location = 'uri' in item.inlineReference ? item.inlineReference : { uri: item.inlineReference };
-            const printUri = ( URI.parse(contentRefUrl)).with({ fragment: JSON.stringify(location) });
-            const markdownText = `[${item.name || basename(location.uri)}](${( printUri.toString())})`;
-            if (previousItem?.kind === 'markdownContent') {
-                result[result.length - 1] = { content: ( new MarkdownString(
-                    previousItem.content.value + markdownText,
-                    { isTrusted: previousItem.content.isTrusted }
-                )), kind: 'markdownContent' };
-            }
-            else {
-                result.push({ content: ( new MarkdownString(markdownText)), kind: 'markdownContent' });
-            }
-        }
-        else if (item.kind === 'markdownContent' && previousItem?.kind === 'markdownContent') {
-            result[result.length - 1] = { content: ( new MarkdownString(
-                previousItem.content.value + item.content.value,
-                { isTrusted: previousItem.content.isTrusted }
-            )), kind: 'markdownContent' };
-        }
-        else if (item.kind === 'markdownVuln') {
-            const vulnText = encodeURIComponent(JSON.stringify(item.vulnerabilities));
-            const markdownText = `<vscode_annotation details="${vulnText}">${item.content.value}</vscode_annotation>`;
-            if (previousItem?.kind === 'markdownContent') {
-                result[result.length - 1] = { content: ( new MarkdownString(
-                    previousItem.content.value + markdownText,
-                    { isTrusted: previousItem.content.isTrusted }
-                )), kind: 'markdownContent' };
-            }
-            else {
-                result.push({ content: ( new MarkdownString(markdownText)), kind: 'markdownContent' });
-            }
-        }
-        else {
-            result.push(item);
-        }
-    }
-    return result;
-}
-export { ChatMarkdownDecorationsRenderer, annotateSpecialMarkdownContent, extractVulnerabilitiesFromText };
+export { ChatMarkdownDecorationsRenderer };

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

@@ -0,0 +1,283 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { isAncestorOfActiveElement, $ } from '../../../../base/browser/dom.js';
+import { Sash } from '../../../../base/browser/ui/sash/sash.js';
+import { disposableTimeout } from '../../../../base/common/async.js';
+import { CancellationToken } from '../../../../base/common/cancellation.js';
+import { Emitter, Event } from '../../../../base/common/event.js';
+import { Disposable, MutableDisposable, DisposableStore } from '../../../../base/common/lifecycle.js';
+import { MenuId } from '../../../../platform/actions/common/actions.js';
+import { IContextKeyService } from '../../../../platform/contextkey/common/contextkey.js';
+import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
+import { ServiceCollection } from '../../../../platform/instantiation/common/serviceCollection.js';
+import { ILayoutService } from '../../../../platform/layout/browser/layoutService.js';
+import { IQuickInputService } from '../../../../platform/quickinput/common/quickInput.js';
+import '../../../../platform/theme/common/colorUtils.js';
+import '../../../../platform/theme/common/colors/baseColors.js';
+import '../../../../platform/theme/common/colors/chartsColors.js';
+import { editorBackground } from '../../../../platform/theme/common/colors/editorColors.js';
+import { inputBackground } from '../../../../platform/theme/common/colors/inputColors.js';
+import '../../../../platform/theme/common/colors/listColors.js';
+import '../../../../platform/theme/common/colors/menuColors.js';
+import '../../../../platform/theme/common/colors/minimapColors.js';
+import '../../../../platform/theme/common/colors/miscColors.js';
+import { quickInputForeground, quickInputBackground } from '../../../../platform/theme/common/colors/quickpickColors.js';
+import '../../../../platform/theme/common/colors/searchColors.js';
+import { IChatWidgetService } from './chat.js';
+import { ChatWidget } from './chatWidget.js';
+import { ChatAgentLocation } from '../common/chatAgents.js';
+import { IChatService } from '../common/chatService.js';
+var QuickChat_1;
+let QuickChatService = class QuickChatService extends Disposable {
+    constructor(quickInputService, chatService, instantiationService) {
+        super();
+        this.quickInputService = quickInputService;
+        this.chatService = chatService;
+        this.instantiationService = instantiationService;
+        this._onDidClose = this._register(( new Emitter()));
+        this.onDidClose = this._onDidClose.event;
+    }
+    get enabled() {
+        return this.chatService.getProviderInfos().length > 0;
+    }
+    get focused() {
+        const widget = this._input?.widget;
+        if (!widget) {
+            return false;
+        }
+        return isAncestorOfActiveElement(widget);
+    }
+    toggle(providerId, options) {
+        if (this.focused && !options?.query) {
+            this.close();
+        }
+        else {
+            this.open(providerId, options);
+            if (options?.isPartialQuery) {
+                const disposable = this._store.add(Event.once(this.onDidClose)(() => {
+                    this._currentChat?.clearValue();
+                    this._store.delete(disposable);
+                }));
+            }
+        }
+    }
+    open(providerId, options) {
+        if (this._input) {
+            if (this._currentChat && options?.query) {
+                this._currentChat.focus();
+                this._currentChat.setValue(options.query, options.selection);
+                if (!options.isPartialQuery) {
+                    this._currentChat.acceptInput();
+                }
+                return;
+            }
+            return this.focus();
+        }
+        const providerInfo = providerId
+            ? this.chatService.getProviderInfos().find(info => info.id === providerId)
+            : this.chatService.getProviderInfos()[0];
+        if (!providerInfo) {
+            return;
+        }
+        const disposableStore = ( new DisposableStore());
+        this._input = this.quickInputService.createQuickWidget();
+        this._input.contextKey = 'chatInputVisible';
+        this._input.ignoreFocusOut = true;
+        disposableStore.add(this._input);
+        this._container ??= $('.interactive-session');
+        this._input.widget = this._container;
+        this._input.show();
+        if (!this._currentChat) {
+            this._currentChat = this.instantiationService.createInstance(QuickChat, {
+                providerId: providerInfo.id,
+            });
+            this._currentChat.render(this._container);
+        }
+        else {
+            this._currentChat.show();
+        }
+        disposableStore.add(this._input.onDidHide(() => {
+            disposableStore.dispose();
+            this._currentChat.hide();
+            this._input = undefined;
+            this._onDidClose.fire();
+        }));
+        this._currentChat.focus();
+        if (options?.query) {
+            this._currentChat.setValue(options.query, options.selection);
+            if (!options.isPartialQuery) {
+                this._currentChat.acceptInput();
+            }
+        }
+    }
+    focus() {
+        this._currentChat?.focus();
+    }
+    close() {
+        this._input?.dispose();
+        this._input = undefined;
+    }
+    async openInChatView() {
+        await this._currentChat?.openChatView();
+        this.close();
+    }
+};
+QuickChatService = ( __decorate([
+    ( __param(0, IQuickInputService)),
+    ( __param(1, IChatService)),
+    ( __param(2, IInstantiationService))
+], QuickChatService));
+let QuickChat = class QuickChat extends Disposable {
+    static { QuickChat_1 = this; }
+    static { this.DEFAULT_MIN_HEIGHT = 200; }
+    static { this.DEFAULT_HEIGHT_OFFSET = 100; }
+    constructor(_options, instantiationService, contextKeyService, chatService, _chatWidgetService, layoutService) {
+        super();
+        this._options = _options;
+        this.instantiationService = instantiationService;
+        this.contextKeyService = contextKeyService;
+        this.chatService = chatService;
+        this._chatWidgetService = _chatWidgetService;
+        this.layoutService = layoutService;
+        this.maintainScrollTimer = this._register(( new MutableDisposable()));
+        this._deferUpdatingDynamicLayout = false;
+    }
+    clear() {
+        this.model?.dispose();
+        this.model = undefined;
+        this.updateModel();
+        this.widget.inputEditor.setValue('');
+    }
+    focus(selection) {
+        if (this.widget) {
+            this.widget.focusInput();
+            const value = this.widget.inputEditor.getValue();
+            if (value) {
+                this.widget.inputEditor.setSelection(selection ?? {
+                    startLineNumber: 1,
+                    startColumn: 1,
+                    endLineNumber: 1,
+                    endColumn: value.length + 1
+                });
+            }
+        }
+    }
+    hide() {
+        this.widget.setVisible(false);
+        this.maintainScrollTimer.value = disposableTimeout(() => {
+            this.maintainScrollTimer.clear();
+        }, 30 * 1000);
+    }
+    show() {
+        this.widget.setVisible(true);
+        if (this._deferUpdatingDynamicLayout) {
+            this._deferUpdatingDynamicLayout = false;
+            this.widget.updateDynamicChatTreeItemLayout(2, this.maxHeight);
+        }
+        if (!this.maintainScrollTimer.value) {
+            this.widget.layoutDynamicChatTreeItemMode();
+        }
+    }
+    render(parent) {
+        if (this.widget) {
+            throw new Error('Cannot render quick chat twice');
+        }
+        const scopedInstantiationService = this.instantiationService.createChild(( new ServiceCollection([
+            IContextKeyService,
+            this._register(this.contextKeyService.createScoped(parent))
+        ])));
+        this.widget = this._register(scopedInstantiationService.createInstance(ChatWidget, ChatAgentLocation.Panel, { resource: true }, { renderInputOnTop: true, renderStyle: 'compact', menus: { inputSideToolbar: MenuId.ChatInputSide } }, {
+            listForeground: quickInputForeground,
+            listBackground: quickInputBackground,
+            inputEditorBackground: inputBackground,
+            resultEditorBackground: editorBackground
+        }));
+        this.widget.render(parent);
+        this.widget.setVisible(true);
+        this.widget.setDynamicChatTreeItemLayout(2, this.maxHeight);
+        this.updateModel();
+        this.sash = this._register(( new Sash(
+            parent,
+            { getHorizontalSashTop: () => parent.offsetHeight },
+            { orientation: 1  }
+        )));
+        this.registerListeners(parent);
+    }
+    get maxHeight() {
+        return this.layoutService.mainContainerDimension.height - QuickChat_1.DEFAULT_HEIGHT_OFFSET;
+    }
+    registerListeners(parent) {
+        this._register(this.layoutService.onDidLayoutMainContainer(() => {
+            if (this.widget.visible) {
+                this.widget.updateDynamicChatTreeItemLayout(2, this.maxHeight);
+            }
+            else {
+                this._deferUpdatingDynamicLayout = true;
+            }
+        }));
+        this._register(this.widget.inputEditor.onDidChangeModelContent((e) => {
+            this._currentQuery = this.widget.inputEditor.getValue();
+        }));
+        this._register(this.widget.onDidClear(() => this.clear()));
+        this._register(this.widget.onDidChangeHeight((e) => this.sash.layout()));
+        const width = parent.offsetWidth;
+        this._register(this.sash.onDidStart(() => {
+            this.widget.isDynamicChatTreeItemLayoutEnabled = false;
+        }));
+        this._register(this.sash.onDidChange((e) => {
+            if (e.currentY < QuickChat_1.DEFAULT_MIN_HEIGHT || e.currentY > this.maxHeight) {
+                return;
+            }
+            this.widget.layout(e.currentY, width);
+            this.sash.layout();
+        }));
+        this._register(this.sash.onDidReset(() => {
+            this.widget.isDynamicChatTreeItemLayoutEnabled = true;
+            this.widget.layoutDynamicChatTreeItemMode();
+        }));
+    }
+    async acceptInput() {
+        return this.widget.acceptInput();
+    }
+    async openChatView() {
+        const widget = await this._chatWidgetService.revealViewForProvider(this._options.providerId);
+        if (!widget?.viewModel || !this.model) {
+            return;
+        }
+        for (const request of this.model.getRequests()) {
+            if (request.response?.response.value || request.response?.result) {
+                this.chatService.addCompleteRequest(widget.viewModel.sessionId, request.message, request.variableData, {
+                    message: request.response.response.value,
+                    result: request.response.result,
+                    followups: request.response.followups
+                });
+            }
+        }
+        const value = this.widget.inputEditor.getValue();
+        if (value) {
+            widget.inputEditor.setValue(value);
+        }
+        widget.focusInput();
+    }
+    setValue(value, selection) {
+        this.widget.inputEditor.setValue(value);
+        this.focus(selection);
+    }
+    clearValue() {
+        this.widget.inputEditor.setValue('');
+    }
+    updateModel() {
+        this.model ??= this.chatService.startSession(this._options.providerId, CancellationToken.None);
+        if (!this.model) {
+            throw new Error('Could not start chat session');
+        }
+        this.widget.setModel(this.model, { inputValue: this._currentQuery });
+    }
+};
+QuickChat = QuickChat_1 = ( __decorate([
+    ( __param(1, IInstantiationService)),
+    ( __param(2, IContextKeyService)),
+    ( __param(3, IChatService)),
+    ( __param(4, IChatWidgetService)),
+    ( __param(5, ILayoutService))
+], QuickChat));
+export { QuickChatService };

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

@@ -0,0 +1,88 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { coalesce } from '../../../../base/common/arrays.js';
+import { onUnexpectedExternalError } from '../../../../base/common/errors.js';
+import { Iterable } from '../../../../base/common/iterator.js';
+import { toDisposable } from '../../../../base/common/lifecycle.js';
+import { IChatWidgetService } from './chat.js';
+import { ChatDynamicVariableModel } from './contrib/chatDynamicVariables.js';
+import { ChatRequestVariablePart, ChatRequestDynamicVariablePart } from '../common/chatParserTypes.js';
+let ChatVariablesService = class ChatVariablesService {
+    constructor(chatWidgetService) {
+        this.chatWidgetService = chatWidgetService;
+        this._resolver = ( new Map());
+    }
+    async resolveVariables(prompt, model, progress, token) {
+        let resolvedVariables = [];
+        const jobs = [];
+        prompt.parts
+            .forEach((part, i) => {
+            if (part instanceof ChatRequestVariablePart) {
+                const data = this._resolver.get(part.variableName.toLowerCase());
+                if (data) {
+                    const references = [];
+                    const variableProgressCallback = (item) => {
+                        if (item.kind === 'reference') {
+                            references.push(item);
+                            return;
+                        }
+                        progress(item);
+                    };
+                    jobs.push(data.resolver(prompt.text, part.variableArg, model, variableProgressCallback, token).then(values => {
+                        resolvedVariables[i] = { name: part.variableName, range: part.range, values: values ?? [], references };
+                    }).catch(onUnexpectedExternalError));
+                }
+            }
+            else if (part instanceof ChatRequestDynamicVariablePart) {
+                resolvedVariables[i] = { name: part.referenceText, range: part.range, values: part.data };
+            }
+        });
+        await Promise.allSettled(jobs);
+        resolvedVariables = coalesce(resolvedVariables);
+        resolvedVariables.sort((a, b) => b.range.start - a.range.start);
+        return {
+            variables: resolvedVariables,
+        };
+    }
+    async resolveVariable(variableName, promptText, model, progress, token) {
+        const data = this._resolver.get(variableName.toLowerCase());
+        if (!data) {
+            return Promise.resolve([]);
+        }
+        return (await data.resolver(promptText, undefined, model, progress, token)) ?? [];
+    }
+    hasVariable(name) {
+        return ( this._resolver.has(name.toLowerCase()));
+    }
+    getVariable(name) {
+        return this._resolver.get(name.toLowerCase())?.data;
+    }
+    getVariables() {
+        const all = ( Iterable.map(( this._resolver.values()), data => data.data));
+        return Iterable.filter(all, data => !data.hidden);
+    }
+    getDynamicVariables(sessionId) {
+        const widget = this.chatWidgetService.getWidgetBySessionId(sessionId);
+        if (!widget || !widget.viewModel || !widget.supportsFileReferences) {
+            return [];
+        }
+        const model = widget.getContrib(ChatDynamicVariableModel.ID);
+        if (!model) {
+            return [];
+        }
+        return model.variables;
+    }
+    registerVariable(data, resolver) {
+        const key = data.name.toLowerCase();
+        if (( this._resolver.has(key))) {
+            throw new Error(`A chat variable with the name '${data.name}' already exists.`);
+        }
+        this._resolver.set(key, { data, resolver });
+        return toDisposable(() => {
+            this._resolver.delete(key);
+        });
+    }
+};
+ChatVariablesService = ( __decorate([
+    ( __param(0, IChatWidgetService))
+], ChatVariablesService));
+export { ChatVariablesService };

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

@@ -0,0 +1,183 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { CancellationToken } from '../../../../base/common/cancellation.js';
+import { DisposableStore } from '../../../../base/common/lifecycle.js';
+import { IConfigurationService } from '../../../../platform/configuration/common/configuration.js';
+import { IContextKeyService } from '../../../../platform/contextkey/common/contextkey.js';
+import { IContextMenuService } from '../../../../platform/contextview/browser/contextView.js';
+import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
+import { ServiceCollection } from '../../../../platform/instantiation/common/serviceCollection.js';
+import { IKeybindingService } from '../../../../platform/keybinding/common/keybinding.js';
+import { ILogService } from '../../../../platform/log/common/log.js';
+import { IOpenerService } from '../../../../platform/opener/common/opener.js';
+import { IStorageService } from '../../../../platform/storage/common/storage.js';
+import { ITelemetryService } from '../../../../platform/telemetry/common/telemetry.js';
+import '../../../../platform/theme/common/colorUtils.js';
+import '../../../../platform/theme/common/colors/baseColors.js';
+import '../../../../platform/theme/common/colors/chartsColors.js';
+import { editorBackground } from '../../../../platform/theme/common/colors/editorColors.js';
+import '../../../../platform/theme/common/colors/inputColors.js';
+import '../../../../platform/theme/common/colors/listColors.js';
+import '../../../../platform/theme/common/colors/menuColors.js';
+import '../../../../platform/theme/common/colors/minimapColors.js';
+import '../../../../platform/theme/common/colors/miscColors.js';
+import '../../../../platform/theme/common/colors/quickpickColors.js';
+import '../../../../platform/theme/common/colors/searchColors.js';
+import { IThemeService } from '../../../../platform/theme/common/themeService.js';
+import { ViewPane } from '../../../browser/parts/views/viewPane.js';
+import { Memento } from '../../../common/memento.js';
+import { SIDE_BAR_FOREGROUND } from '../../../common/theme.js';
+import { IViewDescriptorService } from '../../../common/views.js';
+import { ChatWidget } from './chatWidget.js';
+import { ChatAgentLocation } from '../common/chatAgents.js';
+import { IChatService } from '../common/chatService.js';
+const CHAT_SIDEBAR_PANEL_ID = 'workbench.panel.chatSidebar';
+let ChatViewPane = class ChatViewPane extends ViewPane {
+    static { this.ID = 'workbench.panel.chat.view'; }
+    get widget() { return this._widget; }
+    constructor(chatViewOptions, options, keybindingService, contextMenuService, configurationService, contextKeyService, viewDescriptorService, instantiationService, openerService, themeService, telemetryService, storageService, chatService, logService) {
+        super(options, keybindingService, contextMenuService, configurationService, contextKeyService, viewDescriptorService, instantiationService, openerService, themeService, telemetryService);
+        this.chatViewOptions = chatViewOptions;
+        this.storageService = storageService;
+        this.chatService = chatService;
+        this.logService = logService;
+        this.modelDisposables = this._register(( new DisposableStore()));
+        this.didProviderRegistrationFail = false;
+        this.didUnregisterProvider = false;
+        this.memento = ( new Memento(
+            'interactive-session-view-' + this.chatViewOptions.providerId,
+            this.storageService
+        ));
+        this.viewState = this.memento.getMemento(1 , 1 );
+        this._register(this.chatService.onDidRegisterProvider(({ providerId }) => {
+            if (providerId === this.chatViewOptions.providerId && !this._widget?.viewModel) {
+                const sessionId = this.getSessionId();
+                const model = sessionId ? this.chatService.getOrRestoreSession(sessionId) : undefined;
+                try {
+                    this._widget.setVisible(false);
+                    this.updateModel(model);
+                    this.didProviderRegistrationFail = false;
+                    this.didUnregisterProvider = false;
+                    this._onDidChangeViewWelcomeState.fire();
+                }
+                finally {
+                    this.widget.setVisible(true);
+                }
+            }
+        }));
+        this._register(this.chatService.onDidUnregisterProvider(({ providerId }) => {
+            if (providerId === this.chatViewOptions.providerId) {
+                this.didUnregisterProvider = true;
+                this._onDidChangeViewWelcomeState.fire();
+            }
+        }));
+    }
+    updateModel(model, viewState) {
+        this.modelDisposables.clear();
+        model = model ?? (this.chatService.transferredSessionData?.sessionId
+            ? this.chatService.getOrRestoreSession(this.chatService.transferredSessionData.sessionId)
+            : this.chatService.startSession(this.chatViewOptions.providerId, CancellationToken.None));
+        if (!model) {
+            throw new Error('Could not start chat session');
+        }
+        this._widget.setModel(model, { ...(viewState ?? this.viewState) });
+        this.viewState.sessionId = model.sessionId;
+    }
+    shouldShowWelcome() {
+        const noPersistedSessions = !this.chatService.hasSessions(this.chatViewOptions.providerId);
+        return this.didUnregisterProvider || !this._widget?.viewModel && (noPersistedSessions || this.didProviderRegistrationFail);
+    }
+    getSessionId() {
+        let sessionId;
+        if (this.chatService.transferredSessionData) {
+            sessionId = this.chatService.transferredSessionData.sessionId;
+            this.viewState.inputValue = this.chatService.transferredSessionData.inputValue;
+        }
+        else {
+            sessionId = this.viewState.sessionId;
+        }
+        return sessionId;
+    }
+    renderBody(parent) {
+        try {
+            super.renderBody(parent);
+            const scopedInstantiationService = this.instantiationService.createChild(( new ServiceCollection([IContextKeyService, this.scopedContextKeyService])));
+            this._widget = this._register(scopedInstantiationService.createInstance(ChatWidget, ChatAgentLocation.Panel, { viewId: this.id }, { supportsFileReferences: true }, {
+                listForeground: SIDE_BAR_FOREGROUND,
+                listBackground: this.getBackgroundColor(),
+                inputEditorBackground: this.getBackgroundColor(),
+                resultEditorBackground: editorBackground
+            }));
+            this._register(this.onDidChangeBodyVisibility(visible => {
+                this._widget.setVisible(visible);
+            }));
+            this._register(this._widget.onDidClear(() => this.clear()));
+            this._widget.render(parent);
+            const sessionId = this.getSessionId();
+            const disposeListener = sessionId ? this._register(this.chatService.onDidDisposeSession((e) => {
+                if (e.reason === 'initializationFailed' && e.providerId === this.chatViewOptions.providerId) {
+                    this.didProviderRegistrationFail = true;
+                    disposeListener?.dispose();
+                    this._onDidChangeViewWelcomeState.fire();
+                }
+            })) : undefined;
+            const model = sessionId ? this.chatService.getOrRestoreSession(sessionId) : undefined;
+            this.updateModel(model);
+        }
+        catch (e) {
+            this.logService.error(e);
+            throw e;
+        }
+    }
+    acceptInput(query) {
+        this._widget.acceptInput(query);
+    }
+    async clear() {
+        if (this.widget.viewModel) {
+            this.chatService.clearSession(this.widget.viewModel.sessionId);
+        }
+        this.updateModel(undefined, { ...this.viewState, inputValue: undefined });
+    }
+    loadSession(sessionId) {
+        if (this.widget.viewModel) {
+            this.chatService.clearSession(this.widget.viewModel.sessionId);
+        }
+        const newModel = this.chatService.getOrRestoreSession(sessionId);
+        this.updateModel(newModel);
+    }
+    focusInput() {
+        this._widget.focusInput();
+    }
+    focus() {
+        super.focus();
+        this._widget.focusInput();
+    }
+    layoutBody(height, width) {
+        super.layoutBody(height, width);
+        this._widget.layout(height, width);
+    }
+    saveState() {
+        if (this._widget) {
+            this._widget.saveState();
+            const widgetViewState = this._widget.getViewState();
+            this.viewState.inputValue = widgetViewState.inputValue;
+            this.viewState.inputState = widgetViewState.inputState;
+            this.memento.saveMemento();
+        }
+        super.saveState();
+    }
+};
+ChatViewPane = ( __decorate([
+    ( __param(2, IKeybindingService)),
+    ( __param(3, IContextMenuService)),
+    ( __param(4, IConfigurationService)),
+    ( __param(5, IContextKeyService)),
+    ( __param(6, IViewDescriptorService)),
+    ( __param(7, IInstantiationService)),
+    ( __param(8, IOpenerService)),
+    ( __param(9, IThemeService)),
+    ( __param(10, ITelemetryService)),
+    ( __param(11, IStorageService)),
+    ( __param(12, IChatService)),
+    ( __param(13, ILogService))
+], ChatViewPane));
+export { CHAT_SIDEBAR_PANEL_ID, ChatViewPane };