@codingame/monaco-vscode-chat-service-override 23.2.2 → 24.1.0

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

@@ -1,10 +1,17 @@
 
+import { registerCss } from '@codingame/monaco-vscode-api/css';
 import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
-import { getWindow, $ } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import * as chatViewPane from './media/chatViewPane.css';
+import { $, append, setVisibility, getWindow, addDisposableListener, EventType, EventHelper } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { StandardMouseEvent } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/mouseEvent';
 import { CancellationToken } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
-import { DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { Event } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { MutableDisposable, toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
 import { MarshalledId } from '@codingame/monaco-vscode-api/vscode/vs/base/common/marshallingIds';
-import { Schemas } from '@codingame/monaco-vscode-api/vscode/vs/base/common/network';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { MenuWorkbenchToolBar } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/browser/toolbar';
+import { MenuId } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions';
 import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
 import { IContextKeyService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service';
 import { IContextMenuService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextview/browser/contextView.service';
@@ -12,7 +19,6 @@ import { IHoverService } from '@codingame/monaco-vscode-api/vscode/vs/platform/h
 import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
 import { ServiceCollection } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/serviceCollection';
 import { IKeybindingService } from '@codingame/monaco-vscode-api/vscode/vs/platform/keybinding/common/keybinding.service';
-import { ILayoutService } from '@codingame/monaco-vscode-api/vscode/vs/platform/layout/browser/layoutService.service';
 import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
 import { IOpenerService } from '@codingame/monaco-vscode-api/vscode/vs/platform/opener/common/opener.service';
 import { StorageScope, StorageTarget } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage';
@@ -29,28 +35,49 @@ import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/mini
 import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/miscColors';
 import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/quickpickColors';
 import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/searchColors';
+import { ChatViewTitleControl } from './chatViewTitleControl.js';
 import { IThemeService } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/themeService.service';
-import { ViewPane } from '@codingame/monaco-vscode-501b06ab-3f58-516b-8a1a-c29d375d3da4-common/vscode/vs/workbench/browser/parts/views/viewPane';
-import { Memento } from '@codingame/monaco-vscode-60014c9d-b815-501d-83a9-4b08725c2ec2-common/vscode/vs/workbench/common/memento';
+import { ViewPane } from '@codingame/monaco-vscode-api/vscode/vs/workbench/browser/parts/views/viewPane';
+import { Memento } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/memento';
 import { SIDE_BAR_FOREGROUND } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/theme';
 import { ViewContainerLocation } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/views';
 import { IViewDescriptorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/views.service';
+import { StartupKind } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/lifecycle/common/lifecycle';
+import { ILifecycleService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/lifecycle/common/lifecycle.service';
 import { IChatAgentService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatAgents.service';
 import { ChatContextKeys } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatContextKeys';
-import { CHAT_PROVIDER_ID } from '@codingame/monaco-vscode-2339d6ac-d6bb-53cd-95ee-81911735d1c7-common/vscode/vs/workbench/contrib/chat/common/chatParticipantContribTypes';
+import { CHAT_PROVIDER_ID } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatParticipantContribTypes';
 import { IChatService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService.service';
+import { localChatSessionType } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService';
 import { IChatSessionsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService.service';
-import { ChatAgentLocation, ChatModeKind } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
-import { ChatWidget } from '@codingame/monaco-vscode-a793b3ee-7ba9-5176-a019-30ec806fdd95-common/vscode/vs/workbench/contrib/chat/browser/chatWidget';
-import { ChatViewWelcomeController } from '@codingame/monaco-vscode-a793b3ee-7ba9-5176-a019-30ec806fdd95-common/vscode/vs/workbench/contrib/chat/browser/viewsWelcome/chatViewWelcomeController';
-import { LocalChatSessionUri } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatUri';
+import { LocalChatSessionUri, getChatSessionType } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatUri';
+import { ChatConfiguration, ChatAgentLocation, ChatModeKind } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
+import { showCloseActiveChatNotification } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/actions/chatCloseNotification';
+import { AgentSessionsControl } from './agentSessions/agentSessionsControl.js';
+import { AgentSessionsListDelegate } from './agentSessions/agentSessionsViewer.js';
+import { ChatWidget } from '@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/chat/browser/chatWidget';
+import { ChatViewWelcomeController } from '@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/chat/browser/viewsWelcome/chatViewWelcomeController';
+import { Position } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/layout/browser/layoutService';
+import { IWorkbenchLayoutService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/layout/browser/layoutService.service';
+import { AgentSessionsViewerOrientation, AgentSessionsViewerPosition } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentSessions';
+import { Link } from '@codingame/monaco-vscode-api/vscode/vs/platform/opener/browser/link';
+import { IProgressService } from '@codingame/monaco-vscode-api/vscode/vs/platform/progress/common/progress.service';
+import { ChatViewId } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat';
+import { disposableTimeout } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { AgentSessionsFilter } from './agentSessions/agentSessionsFilter.js';
+import { IAgentSessionsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentSessionsService.service';
+import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
 
-const CHAT_SIDEBAR_PANEL_ID = 'workbench.panel.chat';
+var ChatViewPane_1;
+registerCss(chatViewPane);
 let ChatViewPane = class ChatViewPane extends ViewPane {
+    static { ChatViewPane_1 = this; }
+    static { this.SESSIONS_LIMIT = 3; }
+    static { this.SESSIONS_SIDEBAR_WIDTH = 300; }
+    static { this.SESSIONS_SIDEBAR_VIEW_MIN_WIDTH = 300  + this.SESSIONS_SIDEBAR_WIDTH; }
     get widget() { return this._widget; }
-    constructor(chatOptions, options, keybindingService, contextMenuService, configurationService, contextKeyService, viewDescriptorService, instantiationService, openerService, themeService, hoverService, storageService, chatService, chatAgentService, logService, layoutService, chatSessionsService, telemetryService) {
+    constructor(options, keybindingService, contextMenuService, configurationService, contextKeyService, viewDescriptorService, instantiationService, openerService, themeService, hoverService, storageService, chatService, chatAgentService, logService, layoutService, chatSessionsService, telemetryService, lifecycleService, progressService, agentSessionsService) {
         super(options, keybindingService, contextMenuService, configurationService, contextKeyService, viewDescriptorService, instantiationService, openerService, themeService, hoverService);
-        this.chatOptions = chatOptions;
         this.storageService = storageService;
         this.chatService = chatService;
         this.chatAgentService = chatAgentService;
@@ -58,110 +85,278 @@ let ChatViewPane = class ChatViewPane extends ViewPane {
         this.layoutService = layoutService;
         this.chatSessionsService = chatSessionsService;
         this.telemetryService = telemetryService;
-        this.modelDisposables = this._register(( new DisposableStore()));
-        this.memento = ( new Memento('interactive-session-view-' + CHAT_PROVIDER_ID, this.storageService));
+        this.progressService = progressService;
+        this.agentSessionsService = agentSessionsService;
+        this.sessionsCount = 0;
+        this.sessionsViewerLimited = true;
+        this.sessionsViewerOrientation = AgentSessionsViewerOrientation.Stacked;
+        this.sessionsViewerPosition = AgentSessionsViewerPosition.Right;
+        this.modelRef = this._register(( new MutableDisposable()));
+        this.memento = ( new Memento(`interactive-session-view-${CHAT_PROVIDER_ID}`, this.storageService));
         this.viewState = this.memento.getMemento(StorageScope.WORKSPACE, StorageTarget.MACHINE);
-        if (this.chatOptions.location === ChatAgentLocation.Chat && !this.viewState.hasMigratedCurrentSession) {
-            const editsMemento = ( new Memento(
-                'interactive-session-view-' + CHAT_PROVIDER_ID + `-edits`,
-                this.storageService
-            ));
-            const lastEditsState = editsMemento.getMemento(StorageScope.WORKSPACE, StorageTarget.MACHINE);
-            if (lastEditsState.sessionId) {
-                this.logService.trace(`ChatViewPane: last edits session was ${lastEditsState.sessionId}`);
-                if (!this.chatService.isPersistedSessionEmpty(LocalChatSessionUri.forSession(lastEditsState.sessionId))) {
-                    this.logService.info(`ChatViewPane: migrating ${lastEditsState.sessionId} to unified view`);
-                    this.viewState.sessionId = lastEditsState.sessionId;
-                    this.viewState.inputValue = lastEditsState.inputValue;
-                    this.viewState.inputState = {
-                        ...lastEditsState.inputState,
-                        chatMode: lastEditsState.inputState?.chatMode ?? ChatModeKind.Edit
-                    };
-                    this.viewState.hasMigratedCurrentSession = true;
-                }
-            }
+        if (lifecycleService.startupKind !== StartupKind.ReloadedWindow &&
+            this.configurationService.getValue(ChatConfiguration.RestoreLastPanelSession) === false) {
+            this.viewState.sessionId = undefined;
         }
-        this._register(this.chatAgentService.onDidChangeAgents(() => {
-            if (this.chatAgentService.getDefaultAgent(this.chatOptions?.location)) {
-                if (!this._widget?.viewModel && !this._restoringSession) {
-                    const info = this.getTransferredOrPersistedSessionInfo();
-                    this._restoringSession =
-                        (info.sessionId ? this.chatService.getOrRestoreSession(LocalChatSessionUri.forSession(info.sessionId)) : Promise.resolve(undefined)).then(async (model) => {
-                            if (!this._widget) {
-                                return;
-                            }
-                            const wasVisible = this._widget.visible;
-                            try {
-                                this._widget.setVisible(false);
-                                await this.updateModel(model, info.inputValue || info.mode ? { inputState: { chatMode: info.mode }, inputValue: info.inputValue } : undefined);
-                            }
-                            finally {
-                                this.widget.setVisible(wasVisible);
+        this.chatViewLocationContext = ChatContextKeys.panelLocation.bindTo(contextKeyService);
+        this.sessionsViewerLimitedContext = ChatContextKeys.agentSessionsViewerLimited.bindTo(contextKeyService);
+        this.sessionsViewerOrientationContext = ChatContextKeys.agentSessionsViewerOrientation.bindTo(contextKeyService);
+        this.sessionsViewerPositionContext = ChatContextKeys.agentSessionsViewerPosition.bindTo(contextKeyService);
+        this.updateContextKeys(false);
+        this.registerListeners();
+    }
+    updateContextKeys(fromEvent) {
+        const viewLocation = this.viewDescriptorService.getViewLocationById(this.id);
+        const sideBarPosition = this.layoutService.getSideBarPosition();
+        const panelPosition = this.layoutService.getPanelPosition();
+        let sideSessionsOnRightPosition;
+        switch (viewLocation) {
+            case ViewContainerLocation.Sidebar:
+                sideSessionsOnRightPosition = sideBarPosition === Position.RIGHT;
+                break;
+            case ViewContainerLocation.Panel:
+                sideSessionsOnRightPosition = panelPosition !== Position.LEFT;
+                break;
+            default:
+                sideSessionsOnRightPosition = sideBarPosition === Position.LEFT;
+                break;
+        }
+        this.sessionsViewerPosition = sideSessionsOnRightPosition ? AgentSessionsViewerPosition.Right : AgentSessionsViewerPosition.Left;
+        this.sessionsViewerLimitedContext.set(this.sessionsViewerLimited);
+        this.chatViewLocationContext.set(viewLocation ?? ViewContainerLocation.AuxiliaryBar);
+        this.sessionsViewerOrientationContext.set(this.sessionsViewerOrientation);
+        this.sessionsViewerPositionContext.set(this.sessionsViewerPosition);
+        if (fromEvent && this.lastDimensions) {
+            this.layoutBody(this.lastDimensions.height, this.lastDimensions.width);
+        }
+    }
+    updateViewPaneClasses(fromEvent) {
+        const welcomeEnabled = this.configurationService.getValue(ChatConfiguration.ChatViewWelcomeEnabled) !== false;
+        this.viewPaneContainer?.classList.toggle('chat-view-welcome-enabled', welcomeEnabled);
+        if (fromEvent && this.lastDimensions) {
+            this.layoutBody(this.lastDimensions.height, this.lastDimensions.width);
+        }
+    }
+    registerListeners() {
+        this._register(this.chatAgentService.onDidChangeAgents(() => this.onDidChangeAgents()));
+        this._register(Event.filter(this.configurationService.onDidChangeConfiguration, e => e.affectsConfiguration('workbench.sideBar.location'))(() => this.updateContextKeys(true)));
+        this._register(this.layoutService.onDidChangePanelPosition(() => this.updateContextKeys(true)));
+        this._register(Event.filter(this.viewDescriptorService.onDidChangeContainerLocation, e => e.viewContainer === this.viewDescriptorService.getViewContainerByViewId(this.id))(() => this.updateContextKeys(true)));
+        this._register(Event.filter(this.configurationService.onDidChangeConfiguration, e => e.affectsConfiguration(ChatConfiguration.ChatViewWelcomeEnabled))(() => this.updateViewPaneClasses(true)));
+    }
+    onDidChangeAgents() {
+        if (this.chatAgentService.getDefaultAgent(ChatAgentLocation.Chat)) {
+            if (!this._widget?.viewModel && !this.restoringSession) {
+                const info = this.getTransferredOrPersistedSessionInfo();
+                this.restoringSession =
+                    (info.sessionId ? this.chatService.getOrRestoreSession(LocalChatSessionUri.forSession(info.sessionId)) : Promise.resolve(undefined)).then(async (modelRef) => {
+                        if (!this._widget) {
+                            return;
+                        }
+                        const wasVisible = this._widget.visible;
+                        try {
+                            this._widget.setVisible(false);
+                            if (info.inputState && modelRef) {
+                                modelRef.object.inputModel.setState(info.inputState);
                             }
-                        });
-                    this._restoringSession.finally(() => this._restoringSession = undefined);
-                }
+                            await this.showModel(modelRef);
+                        }
+                        finally {
+                            this._widget.setVisible(wasVisible);
+                        }
+                    });
+                this.restoringSession.finally(() => this.restoringSession = undefined);
             }
-            this._onDidChangeViewWelcomeState.fire();
-        }));
-        ChatContextKeys.panelLocation.bindTo(contextKeyService).set(viewDescriptorService.getViewLocationById(options.id) ?? ViewContainerLocation.AuxiliaryBar);
+        }
+        this._onDidChangeViewWelcomeState.fire();
+    }
+    getTransferredOrPersistedSessionInfo() {
+        if (this.chatService.transferredSessionData?.location === ChatAgentLocation.Chat) {
+            const sessionId = this.chatService.transferredSessionData.sessionId;
+            return {
+                sessionId,
+                inputState: this.chatService.transferredSessionData.inputState,
+            };
+        }
+        return { sessionId: this.viewState.sessionId };
     }
     getActionsContext() {
-        return this.widget?.viewModel ? {
-            sessionResource: this.widget.viewModel.sessionResource,
+        return this._widget?.viewModel ? {
+            sessionResource: this._widget.viewModel.sessionResource,
             $mid: MarshalledId.ChatViewContext
         } : undefined;
     }
-    async updateModel(model, viewState) {
-        this.modelDisposables.clear();
-        model = model ?? (this.chatService.transferredSessionData?.sessionId && this.chatService.transferredSessionData?.location === this.chatOptions.location
-            ? await this.chatService.getOrRestoreSession(LocalChatSessionUri.forSession(this.chatService.transferredSessionData.sessionId))
-            : this.chatService.startSession(this.chatOptions.location, CancellationToken.None));
-        if (!model) {
-            throw ( new Error('Could not start chat session'));
-        }
-        if (viewState) {
-            this.updateViewState(viewState);
-        }
-        this.viewState.sessionId = model.sessionId;
-        this._widget.setModel(model, { ...this.viewState });
+    async showModel(modelRef, startNewSession = true) {
+        if (this.modelRef.value?.object.requestInProgress.get()) {
+            const closingSessionResource = this.modelRef.value.object.sessionResource;
+            this.instantiationService.invokeFunction(showCloseActiveChatNotification, closingSessionResource);
+        }
+        const oldModelResource = this.modelRef.value?.object.sessionResource;
+        this.modelRef.value = undefined;
+        let ref;
+        if (startNewSession) {
+            ref = modelRef ?? (this.chatService.transferredSessionData?.sessionId && this.chatService.transferredSessionData?.location === ChatAgentLocation.Chat
+                ? await this.chatService.getOrRestoreSession(LocalChatSessionUri.forSession(this.chatService.transferredSessionData.sessionId))
+                : this.chatService.startSession(ChatAgentLocation.Chat));
+            if (!ref) {
+                throw ( new Error('Could not start chat session'));
+            }
+        }
+        this.modelRef.value = ref;
+        const model = ref?.object;
+        if (model) {
+            await this.updateWidgetLockState(model.sessionResource);
+            this.viewState.sessionId = model.sessionId;
+        }
+        this._widget.setModel(model);
+        this.titleControl?.update(model);
         this.updateActions();
+        if (oldModelResource) {
+            this.agentSessionsService.model.getSession(oldModelResource)?.setRead(true);
+        }
+        return model;
     }
     shouldShowWelcome() {
         const noPersistedSessions = !this.chatService.hasSessions();
-        const hasCoreAgent = ( this.chatAgentService.getAgents().some(
-            agent => agent.isCore && agent.locations.includes(this.chatOptions.location)
-        ));
-        const hasDefaultAgent = this.chatAgentService.getDefaultAgent(this.chatOptions.location) !== undefined;
+        const hasCoreAgent = ( this.chatAgentService.getAgents().some(agent => agent.isCore && agent.locations.includes(ChatAgentLocation.Chat)));
+        const hasDefaultAgent = this.chatAgentService.getDefaultAgent(ChatAgentLocation.Chat) !== undefined;
         const shouldShow = !hasCoreAgent && (!hasDefaultAgent || !this._widget?.viewModel && noPersistedSessions);
-        this.logService.trace(`ChatViewPane#shouldShowWelcome(${this.chatOptions.location}) = ${shouldShow}: hasCoreAgent=${hasCoreAgent} hasDefaultAgent=${hasDefaultAgent} || noViewModel=${!this._widget?.viewModel} && noPersistedSessions=${noPersistedSessions}`);
+        this.logService.trace(`ChatViewPane#shouldShowWelcome() = ${shouldShow}: hasCoreAgent=${hasCoreAgent} hasDefaultAgent=${hasDefaultAgent} || noViewModel=${!this._widget?.viewModel} && noPersistedSessions=${noPersistedSessions}`);
         return !!shouldShow;
     }
-    getTransferredOrPersistedSessionInfo() {
-        if (this.chatService.transferredSessionData?.location === this.chatOptions.location) {
-            const sessionId = this.chatService.transferredSessionData.sessionId;
-            return {
-                sessionId,
-                inputValue: this.chatService.transferredSessionData.inputValue,
-                mode: this.chatService.transferredSessionData.mode
+    renderBody(parent) {
+        super.renderBody(parent);
+        this.telemetryService.publicLog2('chatViewPaneOpened');
+        this.viewPaneContainer = parent;
+        this.viewPaneContainer.classList.add('chat-viewpane');
+        this.updateViewPaneClasses(false);
+        this.createControls(parent);
+        this.setupContextMenu(parent);
+        this.applyModel();
+    }
+    createControls(parent) {
+        const sessionsControl = this.createSessionsControl(parent);
+        const welcomeController = this.welcomeController = this._register(this.instantiationService.createInstance(ChatViewWelcomeController, parent, this, ChatAgentLocation.Chat));
+        const chatWidget = this.createChatControl(parent);
+        this.registerControlsListeners(sessionsControl, chatWidget, welcomeController);
+        this.updateSessionsControlVisibility();
+    }
+    createSessionsControl(parent) {
+        const that = this;
+        const sessionsContainer = this.sessionsContainer = parent.appendChild($('.agent-sessions-container'));
+        const sessionsTitleContainer = this.sessionsTitleContainer = append(sessionsContainer, $('.agent-sessions-title-container'));
+        const sessionsTitle = this.sessionsTitle = append(sessionsTitleContainer, $('span.agent-sessions-title'));
+        sessionsTitle.textContent = this.sessionsViewerLimited ? ( localize(5646, "Recent Sessions")) : ( localize(5647, "All Sessions"));
+        const sessionsToolbarContainer = append(sessionsTitleContainer, $('.agent-sessions-toolbar'));
+        const sessionsToolbar = this._register(this.instantiationService.createInstance(MenuWorkbenchToolBar, sessionsToolbarContainer, MenuId.AgentSessionsToolbar, {
+            menuOptions: { shouldForwardArgs: true }
+        }));
+        const sessionsFilter = this._register(this.instantiationService.createInstance(AgentSessionsFilter, {
+            filterMenuId: MenuId.AgentSessionsViewerFilterSubMenu,
+            limitResults: () => {
+                return that.sessionsViewerLimited ? ChatViewPane_1.SESSIONS_LIMIT : undefined;
+            },
+            overrideExclude(session) {
+                if (that.sessionsViewerLimited) {
+                    if (session.isArchived()) {
+                        return true;
+                    }
+                    return false;
+                }
+                return undefined;
+            },
+            notifyResults(count) {
+                that.notifySessionsControlCountChanged(count);
+            }
+        }));
+        this._register(Event.runAndSubscribe(sessionsFilter.onDidChange, () => {
+            sessionsToolbarContainer.classList.toggle('filtered', !sessionsFilter.isDefault());
+        }));
+        this.sessionsControlContainer = append(sessionsContainer, $('.agent-sessions-control-container'));
+        const sessionsControl = this.sessionsControl = this._register(this.instantiationService.createInstance(AgentSessionsControl, this.sessionsControlContainer, {
+            allowOpenSessionsInPanel: true,
+            filter: sessionsFilter
+        }));
+        this._register(this.onDidChangeBodyVisibility(visible => sessionsControl.setVisible(visible)));
+        sessionsToolbar.context = sessionsControl;
+        this.sessionsLinkContainer = append(sessionsContainer, $('.agent-sessions-link-container'));
+        this.sessionsLink = this._register(this.instantiationService.createInstance(Link, this.sessionsLinkContainer, {
+            label: this.sessionsViewerLimited ? ( localize(5648, "Show All Sessions")) : ( localize(5649, "Show Recent Sessions")),
+            href: '',
+        }, {
+            opener: () => {
+                this.sessionsViewerLimited = !this.sessionsViewerLimited;
+                this.notifySessionsControlLimitedChanged(true);
+                sessionsControl.focus();
+            }
+        }));
+        return sessionsControl;
+    }
+    notifySessionsControlLimitedChanged(triggerLayout) {
+        this.sessionsViewerLimitedContext.set(this.sessionsViewerLimited);
+        if (this.sessionsTitle) {
+            this.sessionsTitle.textContent = this.sessionsViewerLimited ? ( localize(5646, "Recent Sessions")) : ( localize(5647, "All Sessions"));
+        }
+        if (this.sessionsLink) {
+            this.sessionsLink.link = {
+                label: this.sessionsViewerLimited ? ( localize(5648, "Show All Sessions")) : ( localize(5649, "Show Recent Sessions")),
+                href: ''
             };
         }
+        this.sessionsControl?.update();
+        if (triggerLayout && this.lastDimensions) {
+            this.layoutBody(this.lastDimensions.height, this.lastDimensions.width);
+        }
+    }
+    notifySessionsControlCountChanged(newSessionsCount) {
+        const countChanged = typeof newSessionsCount === 'number' && newSessionsCount !== this.sessionsCount;
+        this.sessionsCount = newSessionsCount ?? this.sessionsCount;
+        const { changed: visibilityChanged, visible } = this.updateSessionsControlVisibility();
+        if (visibilityChanged || (countChanged && visible)) {
+            if (this.lastDimensions) {
+                this.layoutBody(this.lastDimensions.height, this.lastDimensions.width);
+            }
+        }
+    }
+    updateSessionsControlVisibility() {
+        if (!this.sessionsContainer || !this.viewPaneContainer) {
+            return { changed: false, visible: false };
+        }
+        let newSessionsContainerVisible;
+        if (!this.configurationService.getValue(ChatConfiguration.ChatViewSessionsEnabled)) {
+            newSessionsContainerVisible = false;
+        }
         else {
-            return { sessionId: this.viewState.sessionId };
+            if (this.sessionsViewerOrientation === AgentSessionsViewerOrientation.Stacked) {
+                newSessionsContainerVisible =
+                    (!this._widget || this._widget?.isEmpty()) &&
+                        !this.welcomeController?.isShowingWelcome.get() &&
+                        (this.sessionsCount > 0 || !this.sessionsViewerLimited);
+            }
+            else {
+                newSessionsContainerVisible = !!this.lastDimensions && this.lastDimensions.width >= ChatViewPane_1.SESSIONS_SIDEBAR_VIEW_MIN_WIDTH;
+            }
         }
+        this.viewPaneContainer.classList.toggle('has-sessions-control', newSessionsContainerVisible);
+        const sessionsContainerVisible = this.sessionsContainer.style.display !== 'none';
+        setVisibility(newSessionsContainerVisible, this.sessionsContainer);
+        return {
+            changed: sessionsContainerVisible !== newSessionsContainerVisible,
+            visible: newSessionsContainerVisible
+        };
     }
-    async renderBody(parent) {
-        super.renderBody(parent);
-        this._register(this.instantiationService.createInstance(ChatViewWelcomeController, parent, this, this.chatOptions.location));
-        this.telemetryService.publicLog2('chatViewPaneOpened');
-        const scopedInstantiationService = this._register(this.instantiationService.createChild(( new ServiceCollection([IContextKeyService, this.scopedContextKeyService]))));
+    createChatControl(parent) {
+        const chatControlsContainer = append(parent, $('.chat-controls-container'));
         const locationBasedColors = this.getLocationBasedColors();
-        const editorOverflowNode = this.layoutService.getContainer(getWindow(parent)).appendChild($('.chat-editor-overflow.monaco-editor'));
-        this._register({ dispose: () => editorOverflowNode.remove() });
-        this._widget = this._register(scopedInstantiationService.createInstance(ChatWidget, this.chatOptions.location, { viewId: this.id }, {
+        const editorOverflowWidgetsDomNode = this.layoutService.getContainer(getWindow(chatControlsContainer)).appendChild($('.chat-editor-overflow.monaco-editor'));
+        this._register(toDisposable(() => editorOverflowWidgetsDomNode.remove()));
+        this.createChatTitleControl(chatControlsContainer);
+        const scopedInstantiationService = this._register(this.instantiationService.createChild(( new ServiceCollection([IContextKeyService, this.scopedContextKeyService]))));
+        this._widget = this._register(scopedInstantiationService.createInstance(ChatWidget, ChatAgentLocation.Chat, { viewId: this.id }, {
             autoScroll: mode => mode !== ChatModeKind.Ask,
-            renderFollowups: this.chatOptions.location === ChatAgentLocation.Chat,
+            renderFollowups: true,
             supportsFileReferences: true,
+            clear: () => this.clear(),
             rendererOptions: {
                 renderTextEditsAsSummary: (uri) => {
                     return true;
@@ -169,8 +364,8 @@ let ChatViewPane = class ChatViewPane extends ViewPane {
                 referencesExpandedWhenEmptyResponse: false,
                 progressMessageAtBottomOfResponse: mode => mode !== ChatModeKind.Ask,
             },
-            editorOverflowWidgetsDomNode: editorOverflowNode,
-            enableImplicitContext: this.chatOptions.location === ChatAgentLocation.Chat,
+            editorOverflowWidgetsDomNode,
+            enableImplicitContext: true,
             enableWorkingSet: 'explicit',
             supportsChangingModes: true,
         }, {
@@ -180,43 +375,74 @@ let ChatViewPane = class ChatViewPane extends ViewPane {
             inputEditorBackground: locationBasedColors.background,
             resultEditorBackground: editorBackground,
         }));
-        this._register(this.onDidChangeBodyVisibility(visible => {
-            this._widget.setVisible(visible);
+        this._widget.render(chatControlsContainer);
+        const updateWidgetVisibility = (reader) => this._widget.setVisible(this.isBodyVisible() && !this.welcomeController?.isShowingWelcome.read(reader));
+        this._register(this.onDidChangeBodyVisibility(() => updateWidgetVisibility()));
+        this._register(autorun(reader => updateWidgetVisibility(reader)));
+        return this._widget;
+    }
+    createChatTitleControl(parent) {
+        this.titleControl = this._register(this.instantiationService.createInstance(ChatViewTitleControl, parent, {
+            updateTitle: title => this.updateTitle(title),
+            focusChat: () => this._widget.focusInput()
+        }));
+        this._register(this.titleControl.onDidChangeHeight(() => {
+            if (this.lastDimensions) {
+                this.layoutBody(this.lastDimensions.height, this.lastDimensions.width);
+            }
         }));
-        this._register(this._widget.onDidClear(() => this.clear()));
-        this._widget.render(parent);
-        const info = this.getTransferredOrPersistedSessionInfo();
-        const model = info.sessionId ? await this.chatService.getOrRestoreSession(LocalChatSessionUri.forSession(info.sessionId)) : undefined;
-        await this.updateModel(model, info.inputValue || info.mode ? { inputState: { chatMode: info.mode }, inputValue: info.inputValue } : undefined);
     }
-    acceptInput(query) {
-        this._widget.acceptInput(query);
+    registerControlsListeners(sessionsControl, chatWidget, welcomeController) {
+        this._register(Event.any(chatWidget.onDidChangeEmptyState, Event.fromObservable(welcomeController.isShowingWelcome), Event.filter(this.configurationService.onDidChangeConfiguration, e => e.affectsConfiguration(ChatConfiguration.ChatViewSessionsEnabled)))(() => {
+            if (this.sessionsViewerOrientation === AgentSessionsViewerOrientation.Stacked) {
+                sessionsControl.clearFocus();
+            }
+            this.notifySessionsControlCountChanged();
+        }));
+        this._register(Event.filter(this.configurationService.onDidChangeConfiguration, e => e.affectsConfiguration(ChatConfiguration.ChatViewSessionsOrientation))(() => {
+            if (this.lastDimensions) {
+                this.layoutBody(this.lastDimensions.height, this.lastDimensions.width);
+            }
+        }));
     }
-    async clear() {
-        if (this.widget.viewModel) {
-            await this.chatService.clearSession(this.widget.viewModel.sessionResource);
+    setupContextMenu(parent) {
+        this._register(addDisposableListener(parent, EventType.CONTEXT_MENU, e => {
+            EventHelper.stop(e, true);
+            this.contextMenuService.showContextMenu({
+                menuId: MenuId.ChatWelcomeContext,
+                contextKeyService: this.contextKeyService,
+                getAnchor: () => ( new StandardMouseEvent(getWindow(parent), e))
+            });
+        }));
+    }
+    async applyModel() {
+        const info = this.getTransferredOrPersistedSessionInfo();
+        const modelRef = info.sessionId ? await this.chatService.getOrRestoreSession(LocalChatSessionUri.forSession(info.sessionId)) : undefined;
+        if (modelRef && info.inputState) {
+            modelRef.object.inputModel.setState(info.inputState);
         }
+        await this.showModel(modelRef);
+    }
+    async clear() {
         this.updateViewState();
-        await this.updateModel(undefined);
+        await this.showModel(undefined);
         this.updateActions();
     }
-    async loadSession(sessionId, viewState) {
-        if (this.widget.viewModel) {
-            await this.chatService.clearSession(this.widget.viewModel.sessionResource);
-        }
-        if (sessionId.scheme === Schemas.vscodeLocalChatSession) {
-            const parsed = LocalChatSessionUri.parse(sessionId);
-            if (parsed?.chatSessionType) {
-                await this.chatSessionsService.canResolveChatSession(sessionId);
-                const contributions = this.chatSessionsService.getAllChatSessionContributions();
-                const contribution = contributions.find((c) => c.type === parsed.chatSessionType);
-                if (contribution) {
-                    this.widget.lockToCodingAgent(contribution.name, contribution.displayName, contribution.type);
-                }
+    async loadSession(sessionResource) {
+        return this.progressService.withProgress({ location: ChatViewId, delay: 200 }, async () => {
+            let queue = Promise.resolve();
+            const clearWidget = disposableTimeout(() => {
+                queue = this.showModel(undefined, false).then(() => { });
+            }, 100);
+            const sessionType = getChatSessionType(sessionResource);
+            if (sessionType !== localChatSessionType) {
+                await this.chatSessionsService.canResolveChatSession(sessionResource);
             }
-        }
-        const newModel = await this.chatService.loadSessionForResource(sessionId, ChatAgentLocation.Chat, CancellationToken.None);
-        await this.updateModel(newModel, viewState);
+            const newModelRef = await this.chatService.loadSessionForResource(sessionResource, ChatAgentLocation.Chat, CancellationToken.None);
+            clearWidget.dispose();
+            await queue;
+            return this.showModel(newModelRef);
+        });
     }
     focusInput() {
         this._widget.focusInput();
@@ -227,7 +453,74 @@ let ChatViewPane = class ChatViewPane extends ViewPane {
     }
     layoutBody(height, width) {
         super.layoutBody(height, width);
-        this._widget.layout(height, width);
+        this.lastDimensions = { height, width };
+        let remainingHeight = height;
+        let remainingWidth = width;
+        const { heightReduction, widthReduction } = this.layoutSessionsControl(remainingHeight, remainingWidth);
+        remainingHeight -= heightReduction;
+        remainingWidth -= widthReduction;
+        remainingHeight -= this.titleControl?.getHeight() ?? 0;
+        this._widget.layout(remainingHeight, remainingWidth);
+    }
+    layoutSessionsControl(height, width) {
+        let heightReduction = 0;
+        let widthReduction = 0;
+        if (!this.sessionsContainer || !this.sessionsControlContainer || !this.sessionsControl || !this.viewPaneContainer || !this.sessionsTitleContainer || !this.sessionsLinkContainer || !this.sessionsTitle || !this.sessionsLink) {
+            return { heightReduction, widthReduction };
+        }
+        const configuredSessionsViewerOrientation = this.configurationService.getValue(ChatConfiguration.ChatViewSessionsOrientation);
+        const oldSessionsViewerOrientation = this.sessionsViewerOrientation;
+        let newSessionsViewerOrientation;
+        switch (configuredSessionsViewerOrientation) {
+            case 'stacked':
+                newSessionsViewerOrientation = AgentSessionsViewerOrientation.Stacked;
+                break;
+            default:
+                newSessionsViewerOrientation = width >= ChatViewPane_1.SESSIONS_SIDEBAR_VIEW_MIN_WIDTH ? AgentSessionsViewerOrientation.SideBySide : AgentSessionsViewerOrientation.Stacked;
+        }
+        this.sessionsViewerOrientation = newSessionsViewerOrientation;
+        if (newSessionsViewerOrientation === AgentSessionsViewerOrientation.SideBySide) {
+            this.viewPaneContainer.classList.add('sessions-control-orientation-sidebyside');
+            this.viewPaneContainer.classList.toggle('sessions-control-position-left', this.sessionsViewerPosition === AgentSessionsViewerPosition.Left);
+            this.sessionsViewerOrientationContext.set(AgentSessionsViewerOrientation.SideBySide);
+        }
+        else {
+            this.viewPaneContainer.classList.remove('sessions-control-orientation-sidebyside');
+            this.viewPaneContainer.classList.remove('sessions-control-position-left');
+            this.sessionsViewerOrientationContext.set(AgentSessionsViewerOrientation.Stacked);
+        }
+        if (oldSessionsViewerOrientation !== this.sessionsViewerOrientation) {
+            const oldSessionsViewerLimited = this.sessionsViewerLimited;
+            this.sessionsViewerLimited = this.sessionsViewerOrientation === AgentSessionsViewerOrientation.Stacked;
+            if (oldSessionsViewerLimited !== this.sessionsViewerLimited) {
+                this.notifySessionsControlLimitedChanged(false );
+            }
+        }
+        this.updateSessionsControlVisibility();
+        const availableSessionsHeight = height - this.sessionsTitleContainer.offsetHeight - this.sessionsLinkContainer.offsetHeight;
+        if (this.sessionsViewerOrientation === AgentSessionsViewerOrientation.SideBySide) {
+            this.sessionsControlContainer.style.height = `${availableSessionsHeight}px`;
+            this.sessionsControlContainer.style.width = `${ChatViewPane_1.SESSIONS_SIDEBAR_WIDTH}px`;
+            this.sessionsControl.layout(availableSessionsHeight, ChatViewPane_1.SESSIONS_SIDEBAR_WIDTH);
+            heightReduction = 0;
+            widthReduction = this.sessionsContainer.offsetWidth;
+        }
+        else {
+            let sessionsHeight;
+            if (this.sessionsViewerLimited) {
+                sessionsHeight = this.sessionsCount * AgentSessionsListDelegate.ITEM_HEIGHT;
+            }
+            else {
+                sessionsHeight = ((ChatViewPane_1.SESSIONS_LIMIT + 2) ) * AgentSessionsListDelegate.ITEM_HEIGHT;
+            }
+            sessionsHeight = Math.min(availableSessionsHeight, sessionsHeight);
+            this.sessionsControlContainer.style.height = `${sessionsHeight}px`;
+            this.sessionsControlContainer.style.width = ``;
+            this.sessionsControl.layout(sessionsHeight, width);
+            heightReduction = this.sessionsContainer.offsetHeight;
+            widthReduction = 0;
+        }
+        return { heightReduction, widthReduction };
     }
     saveState() {
         if (this._widget?.viewModel) {
@@ -239,28 +532,67 @@ let ChatViewPane = class ChatViewPane extends ViewPane {
     }
     updateViewState(viewState) {
         const newViewState = viewState ?? this._widget.getViewState();
-        for (const [key, value] of Object.entries(newViewState)) {
-            this.viewState[key] = value;
+        if (newViewState) {
+            for (const [key, value] of Object.entries(newViewState)) {
+                this.viewState[key] = value;
+            }
+        }
+    }
+    async updateWidgetLockState(sessionResource) {
+        const sessionType = getChatSessionType(sessionResource);
+        if (sessionType === localChatSessionType) {
+            this._widget.unlockFromCodingAgent();
+            return;
+        }
+        let canResolve = false;
+        try {
+            canResolve = await this.chatSessionsService.canResolveChatSession(sessionResource);
+        }
+        catch (error) {
+            this.logService.warn(`Failed to resolve chat session '${( sessionResource.toString())}' for locking`, error);
+        }
+        if (!canResolve) {
+            this._widget.unlockFromCodingAgent();
+            return;
+        }
+        const contribution = this.chatSessionsService.getChatSessionContribution(sessionType);
+        if (contribution) {
+            this._widget.lockToCodingAgent(contribution.name, contribution.displayName, contribution.type);
+        }
+        else {
+            this._widget.unlockFromCodingAgent();
+        }
+    }
+    get singleViewPaneContainerTitle() {
+        if (this.titleControl) {
+            const titleControlTitle = this.titleControl.getSingleViewPaneContainerTitle();
+            if (titleControlTitle) {
+                return titleControlTitle;
+            }
         }
+        return super.singleViewPaneContainerTitle;
     }
 };
-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, IHoverService)),
-    ( __param(11, IStorageService)),
-    ( __param(12, IChatService)),
-    ( __param(13, IChatAgentService)),
-    ( __param(14, ILogService)),
-    ( __param(15, ILayoutService)),
-    ( __param(16, IChatSessionsService)),
-    ( __param(17, ITelemetryService))
+ChatViewPane = ChatViewPane_1 = ( __decorate([
+    ( __param(1, IKeybindingService)),
+    ( __param(2, IContextMenuService)),
+    ( __param(3, IConfigurationService)),
+    ( __param(4, IContextKeyService)),
+    ( __param(5, IViewDescriptorService)),
+    ( __param(6, IInstantiationService)),
+    ( __param(7, IOpenerService)),
+    ( __param(8, IThemeService)),
+    ( __param(9, IHoverService)),
+    ( __param(10, IStorageService)),
+    ( __param(11, IChatService)),
+    ( __param(12, IChatAgentService)),
+    ( __param(13, ILogService)),
+    ( __param(14, IWorkbenchLayoutService)),
+    ( __param(15, IChatSessionsService)),
+    ( __param(16, ITelemetryService)),
+    ( __param(17, ILifecycleService)),
+    ( __param(18, IProgressService)),
+    ( __param(19, IAgentSessionsService))
 ], ChatViewPane));
 
-export { CHAT_SIDEBAR_PANEL_ID, ChatViewPane };
+export { ChatViewPane };