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

package/vscode/src/vs/workbench/contrib/chat/browser/chatSessions.contribution.js

@@ -5,7 +5,7 @@ import { raceCancellationError } from '@codingame/monaco-vscode-api/vscode/vs/ba
 import { CancellationToken } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
 import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
 import { Emitter, Event } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
-import { Disposable, DisposableMap, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { Disposable, DisposableMap, DisposableStore, combinedDisposable, toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
 import { ResourceMap } from '@codingame/monaco-vscode-api/vscode/vs/base/common/map';
 import { Schemas } from '@codingame/monaco-vscode-api/vscode/vs/base/common/network';
 import { joinPath } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
@@ -26,51 +26,59 @@ import { IEditorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench
 import { isProposedApiEnabled } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extensions';
 import { IExtensionService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extensions.service';
 import { ExtensionsRegistry } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extensionsRegistry';
-import { ChatEditorInput } from '@codingame/monaco-vscode-aac7027b-326c-513a-95a9-e4eedd151b38-common/vscode/vs/workbench/contrib/chat/browser/chatEditorInput';
+import { ChatEditorInput } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chatEditorInput';
 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 { localChatSessionType, ChatSessionStatus } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService';
 import '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
-import { AGENT_SESSIONS_VIEWLET_ID, ChatModeKind, ChatAgentLocation } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
-import { CHAT_CATEGORY } from '@codingame/monaco-vscode-2339d6ac-d6bb-53cd-95ee-81911735d1c7-common/vscode/vs/workbench/contrib/chat/browser/actions/chatActions';
-import { NEW_CHAT_SESSION_ACTION_ID } from '@codingame/monaco-vscode-2339d6ac-d6bb-53cd-95ee-81911735d1c7-common/vscode/vs/workbench/contrib/chat/browser/chatSessions/common';
+import { LEGACY_AGENT_SESSIONS_VIEW_ID, ChatAgentLocation, ChatModeKind } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
+import { CHAT_CATEGORY } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/actions/chatActions';
+import { NEW_CHAT_SESSION_ACTION_ID } from '@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/chat/browser/chatSessions/common';
+import { IChatToolInvocation } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService';
+import { IChatService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService.service';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { renderAsPlaintext } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/markdownRenderer';
+import { IViewsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/views/common/viewsService.service';
+import { ChatViewId } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat';
+import { autorunIterableDelta, autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
+import { observableSignalFromEvent } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableSignalFromEvent';
 
 const extensionPoint = ExtensionsRegistry.registerExtensionPoint({
     extensionPoint: 'chatSessions',
     jsonSchema: {
-        description: ( localize(5386, 'Contributes chat session integrations to the chat widget.')),
+        description: ( localize(5466, 'Contributes chat session integrations to the chat widget.')),
         type: 'array',
         items: {
             type: 'object',
             additionalProperties: false,
             properties: {
                 type: {
-                    description: ( localize(5387, 'Unique identifier for the type of chat session.')),
+                    description: ( localize(5467, 'Unique identifier for the type of chat session.')),
                     type: 'string',
                 },
                 name: {
                     description: ( localize(
-                        5388,
+                        5468,
                         'Name of the dynamically registered chat participant (eg: @agent). Must not contain whitespace.'
                     )),
                     type: 'string',
                     pattern: '^[\\w-]+$'
                 },
                 displayName: {
-                    description: ( localize(5389, 'A longer name for this item which is used for display in menus.')),
+                    description: ( localize(5469, 'A longer name for this item which is used for display in menus.')),
                     type: 'string',
                 },
                 description: {
-                    description: ( localize(5390, 'Description of the chat session for use in menus and tooltips.')),
+                    description: ( localize(5470, 'Description of the chat session for use in menus and tooltips.')),
                     type: 'string'
                 },
                 when: {
-                    description: ( localize(5391, 'Condition which must be true to show this item.')),
+                    description: ( localize(5471, 'Condition which must be true to show this item.')),
                     type: 'string'
                 },
                 icon: {
                     description: ( localize(
-                        5392,
+                        5472,
                         'Icon identifier (codicon ID) for the chat session editor tab. For example, "$(github)" or "$(cloud)".'
                     )),
                     anyOf: [{
@@ -80,22 +88,22 @@ const extensionPoint = ExtensionsRegistry.registerExtensionPoint({
                             type: 'object',
                             properties: {
                                 light: {
-                                    description: ( localize(5393, 'Icon path when a light theme is used')),
+                                    description: ( localize(5473, 'Icon path when a light theme is used')),
                                     type: 'string'
                                 },
                                 dark: {
-                                    description: ( localize(5394, 'Icon path when a dark theme is used')),
+                                    description: ( localize(5474, 'Icon path when a dark theme is used')),
                                     type: 'string'
                                 }
                             }
                         }]
                 },
                 order: {
-                    description: ( localize(5395, 'Order in which this item should be displayed.')),
+                    description: ( localize(5475, 'Order in which this item should be displayed.')),
                     type: 'integer'
                 },
                 alternativeIds: {
-                    description: ( localize(5396, 'Alternative identifiers for backward compatibility.')),
+                    description: ( localize(5476, 'Alternative identifiers for backward compatibility.')),
                     type: 'array',
                     items: {
                         type: 'string'
@@ -103,87 +111,87 @@ const extensionPoint = ExtensionsRegistry.registerExtensionPoint({
                 },
                 welcomeTitle: {
                     description: ( localize(
-                        5397,
+                        5477,
                         'Title text to display in the chat welcome view for this session type.'
                     )),
                     type: 'string'
                 },
                 welcomeMessage: {
                     description: ( localize(
-                        5398,
+                        5478,
                         'Message text (supports markdown) to display in the chat welcome view for this session type.'
                     )),
                     type: 'string'
                 },
                 welcomeTips: {
                     description: ( localize(
-                        5399,
+                        5479,
                         'Tips text (supports markdown and theme icons) to display in the chat welcome view for this session type.'
                     )),
                     type: 'string'
                 },
                 inputPlaceholder: {
                     description: ( localize(
-                        5400,
+                        5480,
                         'Placeholder text to display in the chat input box for this session type.'
                     )),
                     type: 'string'
                 },
                 capabilities: {
-                    description: ( localize(5401, 'Optional capabilities for this chat session.')),
+                    description: ( localize(5481, 'Optional capabilities for this chat session.')),
                     type: 'object',
                     additionalProperties: false,
                     properties: {
                         supportsFileAttachments: {
                             description: ( localize(
-                                5402,
+                                5482,
                                 'Whether this chat session supports attaching files or file references.'
                             )),
                             type: 'boolean'
                         },
                         supportsToolAttachments: {
                             description: ( localize(
-                                5403,
+                                5483,
                                 'Whether this chat session supports attaching tools or tool references.'
                             )),
                             type: 'boolean'
                         },
                         supportsMCPAttachments: {
-                            description: ( localize(5404, 'Whether this chat session supports attaching MCP resources.')),
+                            description: ( localize(5484, 'Whether this chat session supports attaching MCP resources.')),
                             type: 'boolean'
                         },
                         supportsImageAttachments: {
-                            description: ( localize(5405, 'Whether this chat session supports attaching images.')),
+                            description: ( localize(5485, 'Whether this chat session supports attaching images.')),
                             type: 'boolean'
                         },
                         supportsSearchResultAttachments: {
-                            description: ( localize(5406, 'Whether this chat session supports attaching search results.')),
+                            description: ( localize(5486, 'Whether this chat session supports attaching search results.')),
                             type: 'boolean'
                         },
                         supportsInstructionAttachments: {
-                            description: ( localize(5407, 'Whether this chat session supports attaching instructions.')),
+                            description: ( localize(5487, 'Whether this chat session supports attaching instructions.')),
                             type: 'boolean'
                         },
                         supportsSourceControlAttachments: {
                             description: ( localize(
-                                5408,
+                                5488,
                                 'Whether this chat session supports attaching source control changes.'
                             )),
                             type: 'boolean'
                         },
                         supportsProblemAttachments: {
-                            description: ( localize(5409, 'Whether this chat session supports attaching problems.')),
+                            description: ( localize(5489, 'Whether this chat session supports attaching problems.')),
                             type: 'boolean'
                         },
                         supportsSymbolAttachments: {
-                            description: ( localize(5410, 'Whether this chat session supports attaching symbols.')),
+                            description: ( localize(5490, 'Whether this chat session supports attaching symbols.')),
                             type: 'boolean'
                         }
                     }
                 },
                 commands: {
                     markdownDescription: ( localize(
-                        5411,
+                        5491,
                         "Commands available for this chat session, which the user can invoke with a `/`."
                     )),
                     type: 'array',
@@ -195,21 +203,29 @@ const extensionPoint = ExtensionsRegistry.registerExtensionPoint({
                         properties: {
                             name: {
                                 description: ( localize(
-                                    5412,
+                                    5492,
                                     "A short name by which this command is referred to in the UI, e.g. `fix` or `explain` for commands that fix an issue or explain code. The name should be unique among the commands provided by this participant."
                                 )),
                                 type: 'string'
                             },
                             description: {
-                                description: ( localize(5413, "A description of this command.")),
+                                description: ( localize(5493, "A description of this command.")),
                                 type: 'string'
                             },
                             when: {
-                                description: ( localize(5414, "A condition which must be true to enable this command.")),
+                                description: ( localize(5494, "A condition which must be true to enable this command.")),
                                 type: 'string'
                             },
                         }
                     }
+                },
+                canDelegate: {
+                    description: ( localize(
+                        5495,
+                        'Whether delegation is supported. Default is false. Note that enabling this is experimental and may not be respected at all times.'
+                    )),
+                    type: 'boolean',
+                    default: false
                 }
             },
             required: ['type', 'name', 'displayName', 'description'],
@@ -249,6 +265,8 @@ class ContributedChatSessionData extends Disposable {
 let ChatSessionsService = class ChatSessionsService extends Disposable {
     get onDidChangeInProgress() { return this._onDidChangeInProgress.event; }
     get onDidChangeContentProviderSchemes() { return this._onDidChangeContentProviderSchemes.event; }
+    get onDidChangeSessionOptions() { return this._onDidChangeSessionOptions.event; }
+    get onDidChangeOptionGroups() { return this._onDidChangeOptionGroups.event; }
     constructor(_logService, _chatAgentService, _extensionService, _contextKeyService, _menuService, _themeService, _labelService) {
         super();
         this._logService = _logService;
@@ -272,6 +290,8 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
         this.onDidChangeAvailability = this._onDidChangeAvailability.event;
         this._onDidChangeInProgress = this._register(( new Emitter()));
         this._onDidChangeContentProviderSchemes = this._register(( new Emitter()));
+        this._onDidChangeSessionOptions = this._register(( new Emitter()));
+        this._onDidChangeOptionGroups = this._register(( new Emitter()));
         this.inProgressMap = ( new Map());
         this._sessionTypeOptions = ( new Map());
         this._sessionTypeIcons = ( new Map());
@@ -330,7 +350,7 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
     async updateInProgressStatus(chatSessionType) {
         try {
             const items = await this.getChatSessionItems(chatSessionType, CancellationToken.None);
-            const inProgress = items.filter(item => item.status === ChatSessionStatus.InProgress);
+            const inProgress = items.filter(item => item.status && this.isChatSessionInProgressStatus(item.status));
             this.reportInProgress(chatSessionType, inProgress.length);
         }
         catch (error) {
@@ -339,7 +359,6 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
     }
     registerContribution(contribution, ext) {
         if (( this._contributions.has(contribution.type))) {
-            this._logService.warn(`Chat session contribution with id '${contribution.type}' is already registered.`);
             return { dispose: () => { } };
         }
         if (contribution.when) {
@@ -426,7 +445,7 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
         if (primaryType) {
             const altContribution = this._contributions.get(primaryType)?.contribution;
             if (altContribution && this._isContributionAvailable(altContribution)) {
-                this._logService.info(`Resolving chat session type '${sessionType}' to alternative type '${primaryType}'`);
+                this._logService.trace(`Resolving chat session type '${sessionType}' to alternative type '${primaryType}'`);
                 return primaryType;
             }
         }
@@ -436,38 +455,39 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
         const contextKeyService = this._contextKeyService.createOverlay([
             ['chatSessionType', contribution.type]
         ]);
-        const rawMenuActions = this._menuService.getMenuActions(MenuId.ChatSessionsCreateSubMenu, contextKeyService);
+        const rawMenuActions = this._menuService.getMenuActions(MenuId.AgentSessionsCreateSubMenu, contextKeyService);
         const menuActions = ( rawMenuActions.map(value => value[1])).flat();
-        const whenClause = ( ContextKeyExpr.and(( ContextKeyExpr.equals('view', `${AGENT_SESSIONS_VIEWLET_ID}.${contribution.type}`))));
+        const whenClause = ( ContextKeyExpr.and(( ContextKeyExpr.equals('view', `${LEGACY_AGENT_SESSIONS_VIEW_ID}.${contribution.type}`))));
+        const disposables = ( new DisposableStore());
         if (menuActions.length === 1) {
             const first = menuActions[0];
             if (first instanceof MenuItemAction) {
-                return MenuRegistry.appendMenuItem(MenuId.ViewTitle, {
+                disposables.add(MenuRegistry.appendMenuItem(MenuId.ViewTitle, {
                     group: 'navigation',
                     title: first.label,
                     icon: Codicon.plus,
                     order: 1,
                     when: whenClause,
                     command: first.item,
-                });
+                }));
             }
         }
         if (menuActions.length) {
-            return MenuRegistry.appendMenuItem(MenuId.ViewTitle, {
+            disposables.add(MenuRegistry.appendMenuItem(MenuId.ViewTitle, {
                 group: 'navigation',
-                title: ( localize(5415, "Create chat session")),
+                title: ( localize(5496, "Create chat session")),
                 icon: Codicon.plus,
                 order: 1,
                 when: whenClause,
-                submenu: MenuId.ChatSessionsCreateSubMenu,
+                submenu: MenuId.AgentSessionsCreateSubMenu,
                 isSplitButton: menuActions.length > 1
-            });
+            }));
         }
         else {
-            return MenuRegistry.appendMenuItem(MenuId.ViewTitle, {
+            disposables.add(MenuRegistry.appendMenuItem(MenuId.ViewTitle, {
                 command: {
                     id: `${NEW_CHAT_SESSION_ACTION_ID}.${contribution.type}`,
-                    title: ( localize(5416, "New {0}", contribution.displayName)),
+                    title: ( localize(5497, "New {0}", contribution.displayName)),
                     icon: Codicon.plus,
                     source: {
                         id: extensionDescription.identifier.value,
@@ -477,31 +497,65 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
                 group: 'navigation',
                 order: 1,
                 when: whenClause,
-            });
+            }));
+        }
+        for (const action of menuActions) {
+            if (action instanceof MenuItemAction) {
+                disposables.add(MenuRegistry.appendMenuItem(MenuId.ChatNewMenu, {
+                    command: action.item,
+                    group: '4_externally_contributed',
+                }));
+            }
         }
+        return {
+            dispose: () => disposables.dispose()
+        };
     }
     _registerCommands(contribution) {
-        return registerAction2(class OpenNewChatSessionEditorAction extends Action2 {
+        return combinedDisposable(registerAction2(class OpenChatSessionAction extends Action2 {
+            constructor() {
+                super({
+                    id: `workbench.action.chat.openSessionWithPrompt.${contribution.type}`,
+                    title: ( localize2(5498, "New {0} with Prompt", contribution.displayName)),
+                    category: CHAT_CATEGORY,
+                    icon: Codicon.plus,
+                    f1: false,
+                    precondition: ChatContextKeys.enabled
+                });
+            }
+            async run(accessor, chatOptions) {
+                const chatService = accessor.get(IChatService);
+                const { type } = contribution;
+                if (chatOptions) {
+                    const resource = URI.revive(chatOptions.resource);
+                    const ref = await chatService.loadSessionForResource(resource, ChatAgentLocation.Chat, CancellationToken.None);
+                    await chatService.sendRequest(resource, chatOptions.prompt, { agentIdSilent: type, attachedContext: chatOptions.attachedContext });
+                    ref?.dispose();
+                }
+            }
+        }),
+        registerAction2(class OpenNewChatSessionEditorAction extends Action2 {
             constructor() {
                 super({
                     id: `workbench.action.chat.openNewSessionEditor.${contribution.type}`,
-                    title: ( localize2(5416, "New {0}", contribution.displayName)),
+                    title: ( localize2(5497, "New {0}", contribution.displayName)),
                     category: CHAT_CATEGORY,
                     icon: Codicon.plus,
                     f1: true,
-                    precondition: ChatContextKeys.enabled
+                    precondition: ChatContextKeys.enabled,
                 });
             }
-            async run(accessor) {
+            async run(accessor, chatOptions) {
                 const editorService = accessor.get(IEditorService);
                 const logService = accessor.get(ILogService);
+                const chatService = accessor.get(IChatService);
                 const { type } = contribution;
                 try {
                     const options = {
                         override: ChatEditorInput.EditorID,
                         pinned: true,
                         title: {
-                            fallback: ( localize(5417, "{0}", contribution.displayName)),
+                            fallback: ( localize(5499, "{0}", contribution.displayName)),
                         }
                     };
                     const resource = ( URI.from({
@@ -509,12 +563,52 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
                         path: `/untitled-${generateUuid()}`,
                     }));
                     await editorService.openEditor({ resource, options });
+                    if (chatOptions?.prompt) {
+                        await chatService.sendRequest(resource, chatOptions.prompt, { agentIdSilent: type, attachedContext: chatOptions.attachedContext });
+                    }
                 }
                 catch (e) {
                     logService.error(`Failed to open new '${type}' chat session editor`, e);
                 }
             }
-        });
+        }),
+        registerAction2(class OpenNewChatSessionSidebarAction extends Action2 {
+            constructor() {
+                super({
+                    id: `workbench.action.chat.openNewSessionSidebar.${contribution.type}`,
+                    title: ( localize2(5500, "New {0}", contribution.displayName)),
+                    category: CHAT_CATEGORY,
+                    icon: Codicon.plus,
+                    f1: false,
+                    precondition: ChatContextKeys.enabled,
+                    menu: {
+                        id: MenuId.ChatNewMenu,
+                        group: '3_new_special',
+                    }
+                });
+            }
+            async run(accessor, chatOptions) {
+                const viewsService = accessor.get(IViewsService);
+                const logService = accessor.get(ILogService);
+                const chatService = accessor.get(IChatService);
+                const { type } = contribution;
+                try {
+                    const resource = ( URI.from({
+                        scheme: type,
+                        path: `/untitled-${generateUuid()}`,
+                    }));
+                    const view = await viewsService.openView(ChatViewId);
+                    await view.loadSession(resource);
+                    if (chatOptions?.prompt) {
+                        await chatService.sendRequest(resource, chatOptions.prompt, { agentIdSilent: type, attachedContext: chatOptions.attachedContext });
+                    }
+                    view.focus();
+                }
+                catch (e) {
+                    logService.error(`Failed to open new '${type}' chat session in sidebar`, e);
+                }
+            }
+        }));
     }
     _evaluateAvailability() {
         let hasChanges = false;
@@ -544,8 +638,10 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
     _enableContribution(contribution, ext) {
         const disposableStore = ( new DisposableStore());
         this._contributionDisposables.set(contribution.type, disposableStore);
-        disposableStore.add(this._registerAgent(contribution, ext));
-        disposableStore.add(this._registerCommands(contribution));
+        if (contribution.canDelegate) {
+            disposableStore.add(this._registerAgent(contribution, ext));
+            disposableStore.add(this._registerCommands(contribution));
+        }
         disposableStore.add(this._registerMenuItems(contribution, ext));
     }
     _disposeSessionsForContribution(contributionId) {
@@ -567,6 +663,12 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
     }
     _registerAgent(contribution, ext) {
         const { type: id, name, displayName, description } = contribution;
+        const storedIcon = this._sessionTypeIcons.get(id);
+        const icons = ThemeIcon.isThemeIcon(storedIcon)
+            ? { themeIcon: storedIcon, icon: undefined, iconDark: undefined }
+            : storedIcon
+                ? { icon: storedIcon.light, iconDark: storedIcon.dark }
+                : { themeIcon: Codicon.sendToRemoteAgent };
         const agentData = {
             id,
             name,
@@ -580,10 +682,10 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
             modes: [ChatModeKind.Agent, ChatModeKind.Ask],
             disambiguation: [],
             metadata: {
-                themeIcon: Codicon.sendToRemoteAgent,
-                isSticky: false,
+                ...icons,
             },
             capabilities: contribution.capabilities,
+            canAccessPreviousChatHistory: true,
             extensionId: ext.identifier,
             extensionVersion: ext.version,
             extensionDisplayName: ext.displayName || ext.name,
@@ -595,13 +697,20 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
         return Array.from(( this._contributions.values()), x => x.contribution)
             .filter(contribution => this._isContributionAvailable(contribution));
     }
+    getChatSessionContribution(chatSessionType) {
+        const contribution = this._contributions.get(chatSessionType)?.contribution;
+        if (!contribution) {
+            return undefined;
+        }
+        return this._isContributionAvailable(contribution) ? contribution : undefined;
+    }
     getAllChatSessionItemProviders() {
         return [...( this._itemsProviders.values())].filter(provider => {
             const contribution = this._contributions.get(provider.chatSessionType)?.contribution;
             return !contribution || this._isContributionAvailable(contribution);
         });
     }
-    async hasChatSessionItemProvider(chatViewType) {
+    async activateChatSessionItemProvider(chatViewType) {
         await this._extensionService.whenInstalledExtensionsRegistered();
         const resolvedType = this._resolveToPrimaryType(chatViewType);
         if (resolvedType) {
@@ -609,13 +718,13 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
         }
         const contribution = this._contributions.get(chatViewType)?.contribution;
         if (contribution && !this._isContributionAvailable(contribution)) {
-            return false;
+            return undefined;
         }
         if (( this._itemsProviders.has(chatViewType))) {
-            return true;
+            return this._itemsProviders.get(chatViewType);
         }
         await this._extensionService.activateByEvent(`onChatSession:${chatViewType}`);
-        return ( this._itemsProviders.has(chatViewType));
+        return this._itemsProviders.get(chatViewType);
     }
     async canResolveChatSession(chatSessionResource) {
         await this._extensionService.whenInstalledExtensionsRegistered();
@@ -639,7 +748,7 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
         }));
     }
     async getChatSessionItems(chatSessionType, token) {
-        if (!(await this.hasChatSessionItemProvider(chatSessionType))) {
+        if (!(await this.activateChatSessionItemProvider(chatSessionType))) {
             return [];
         }
         const resolvedType = this._resolveToPrimaryType(chatSessionType);
@@ -694,21 +803,87 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
             }
         };
     }
-    async getNewChatSessionItem(chatSessionType, options, token) {
-        if (!(await this.hasChatSessionItemProvider(chatSessionType))) {
-            throw Error(`Cannot find provider for ${chatSessionType}`);
-        }
-        const resolvedType = this._resolveToPrimaryType(chatSessionType);
-        if (resolvedType) {
-            chatSessionType = resolvedType;
-        }
-        const provider = this._itemsProviders.get(chatSessionType);
-        if (!provider?.provideNewChatSessionItem) {
-            throw Error(`Provider for ${chatSessionType} does not support creating sessions`);
+    registerChatModelChangeListeners(chatService, chatSessionType, onChange) {
+        const disposableStore = ( new DisposableStore());
+        const chatModelsICareAbout = ( chatService.chatModels.map(
+            models => Array.from(models).filter((model) => model.sessionResource.scheme === chatSessionType)
+        ));
+        const listeners = ( new ResourceMap());
+        const autoRunDisposable = autorunIterableDelta(reader => chatModelsICareAbout.read(reader), ({ addedValues, removedValues }) => {
+            removedValues.forEach((removed) => {
+                const listener = listeners.get(removed.sessionResource);
+                if (listener) {
+                    listeners.delete(removed.sessionResource);
+                    listener.dispose();
+                }
+            });
+            addedValues.forEach((added) => {
+                const requestChangeListener = ( added.lastRequestObs.map(
+                    last => last?.response && observableSignalFromEvent('chatSessions.modelRequestChangeListener', last.response.onDidChange)
+                ));
+                const modelChangeListener = observableSignalFromEvent('chatSessions.modelChangeListener', added.onDidChange);
+                listeners.set(added.sessionResource, autorun(reader => {
+                    requestChangeListener.read(reader)?.read(reader);
+                    modelChangeListener.read(reader);
+                    onChange();
+                }));
+            });
+        });
+        disposableStore.add(toDisposable(() => {
+            for (const listener of ( listeners.values())) {
+                listener.dispose();
+            }
+        }));
+        disposableStore.add(autoRunDisposable);
+        return disposableStore;
+    }
+    getInProgressSessionDescription(chatModel) {
+        const requests = chatModel.getRequests();
+        if (requests.length === 0) {
+            return undefined;
+        }
+        const lastRequest = requests.at(-1);
+        const response = lastRequest?.response;
+        if (!response) {
+            return undefined;
+        }
+        if (response.isComplete) {
+            return undefined;
+        }
+        const responseParts = response.response.value;
+        let description = '';
+        for (let i = responseParts.length - 1; i >= 0; i--) {
+            const part = responseParts[i];
+            if (description) {
+                break;
+            }
+            if (part.kind === 'confirmation' && typeof part.message === 'string') {
+                description = part.message;
+            }
+            else if (part.kind === 'toolInvocation') {
+                const toolInvocation = part;
+                const state = toolInvocation.state.get();
+                description = toolInvocation.generatedTitle || toolInvocation.pastTenseMessage || toolInvocation.invocationMessage;
+                if (state.type === IChatToolInvocation.StateKind.WaitingForConfirmation) {
+                    const confirmationTitle = toolInvocation.confirmationMessages?.title;
+                    const titleMessage = confirmationTitle && (typeof confirmationTitle === 'string'
+                        ? confirmationTitle
+                        : confirmationTitle.value);
+                    const descriptionValue = typeof description === 'string' ? description : description.value;
+                    description = titleMessage ?? ( localize(5501, "Waiting for confirmation: {0}", descriptionValue));
+                }
+            }
+            else if (part.kind === 'toolInvocationSerialized') {
+                description = part.invocationMessage;
+            }
+            else if (part.kind === 'progressMessage') {
+                description = part.content;
+            }
+            else if (part.kind === 'thinking') {
+                description = ( localize(5502, 'Thinking...'));
+            }
         }
-        const chatSessionItem = await provider.provideNewChatSessionItem(options, token);
-        this._onDidChangeSessionItems.fire(chatSessionType);
-        return chatSessionItem;
+        return renderAsPlaintext(description, { useLinkFormatter: true });
     }
     async getOrCreateChatSession(sessionResource, token) {
         const existingSessionData = this._sessions.get(sessionResource);
@@ -774,6 +949,7 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
         else {
             this._sessionTypeOptions.delete(chatSessionType);
         }
+        this._onDidChangeOptionGroups.fire(chatSessionType);
     }
     getOptionGroupsForSessionType(chatSessionType) {
         return this._sessionTypeOptions.get(chatSessionType);
@@ -791,6 +967,7 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
         for (const u of updates) {
             this.setSessionOption(sessionResource, u.optionId, u.value);
         }
+        this._onDidChangeSessionOptions.fire(sessionResource);
     }
     getIconForSessionType(chatSessionType) {
         const sessionTypeIcon = this._sessionTypeIcons.get(chatSessionType);
@@ -820,6 +997,9 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
     getContentProviderSchemes() {
         return Array.from(( this._contentProviders.keys()));
     }
+    isChatSessionInProgressStatus(state) {
+        return state === ChatSessionStatus.InProgress || state === ChatSessionStatus.NeedsInput;
+    }
 };
 ChatSessionsService = ( __decorate([
     ( __param(0, ILogService)),