@codingame/monaco-vscode-chat-service-override 22.1.8 → 23.0.0

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

@@ -1,81 +1,189 @@
 
 import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { sep } from '@codingame/monaco-vscode-api/vscode/vs/base/common/path';
+import { raceCancellationError } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
 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 { DisposableStore, Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { Disposable, DisposableMap, DisposableStore } 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';
+import { ThemeIcon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/themables';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
 import { generateUuid } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uuid';
 import { localize, localize2 } from '@codingame/monaco-vscode-api/vscode/vs/nls';
-import { MenuRegistry, MenuId, registerAction2, Action2 } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions';
+import { MenuId, MenuItemAction, MenuRegistry, registerAction2, Action2 } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions';
+import { IMenuService } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions.service';
 import { ContextKeyExpr } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey';
 import { IContextKeyService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service';
 import '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/extensions';
+import { ILabelService } from '@codingame/monaco-vscode-api/vscode/vs/platform/label/common/label.service';
 import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
+import { isDark } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/theme';
+import { IThemeService } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/themeService.service';
 import { IEditorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service';
 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-b994942c-360d-5b68-8a33-77d4bde6b714-common/vscode/vs/workbench/contrib/chat/browser/chatEditorInput';
+import { ChatEditorInput } from '@codingame/monaco-vscode-aac7027b-326c-513a-95a9-e4eedd151b38-common/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 { ChatSessionStatus } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService';
+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 { ChatSessionUri } from '@codingame/monaco-vscode-b994942c-360d-5b68-8a33-77d4bde6b714-common/vscode/vs/workbench/contrib/chat/common/chatUri';
-import { VIEWLET_ID, ChatModeKind, ChatAgentLocation } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
-import { CHAT_CATEGORY } from '@codingame/monaco-vscode-c2deffc4-ad68-5e63-8f95-9b89e0fc6898-common/vscode/vs/workbench/contrib/chat/browser/actions/chatActions';
-import { NEW_CHAT_SESSION_ACTION_ID } from './chatSessions/common.js';
+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';
 
 const extensionPoint = ExtensionsRegistry.registerExtensionPoint({
     extensionPoint: 'chatSessions',
     jsonSchema: {
-        description: ( localize(5221, 'Contributes chat session integrations to the chat widget.')),
+        description: ( localize(5366, 'Contributes chat session integrations to the chat widget.')),
         type: 'array',
         items: {
             type: 'object',
+            additionalProperties: false,
             properties: {
                 type: {
-                    description: ( localize(5222, 'Unique identifier for the type of chat session.')),
+                    description: ( localize(5367, 'Unique identifier for the type of chat session.')),
                     type: 'string',
                 },
                 name: {
-                    description: ( localize(5223, 'Name shown in the chat widget. (eg: @agent)')),
+                    description: ( localize(
+                        5368,
+                        'Name of the dynamically registered chat participant (eg: @agent). Must not contain whitespace.'
+                    )),
                     type: 'string',
+                    pattern: '^[\\w-]+$'
                 },
                 displayName: {
-                    description: ( localize(5224, 'A longer name for this item which is used for display in menus.')),
+                    description: ( localize(5369, 'A longer name for this item which is used for display in menus.')),
                     type: 'string',
                 },
                 description: {
-                    description: ( localize(5225, 'Description of the chat session for use in menus and tooltips.')),
+                    description: ( localize(5370, 'Description of the chat session for use in menus and tooltips.')),
                     type: 'string'
                 },
                 when: {
-                    description: ( localize(5226, 'Condition which must be true to show this item.')),
+                    description: ( localize(5371, 'Condition which must be true to show this item.')),
+                    type: 'string'
+                },
+                icon: {
+                    description: ( localize(
+                        5372,
+                        'Icon identifier (codicon ID) for the chat session editor tab. For example, "$(github)" or "$(cloud)".'
+                    )),
+                    anyOf: [{
+                            type: 'string'
+                        },
+                        {
+                            type: 'object',
+                            properties: {
+                                light: {
+                                    description: ( localize(5373, 'Icon path when a light theme is used')),
+                                    type: 'string'
+                                },
+                                dark: {
+                                    description: ( localize(5374, 'Icon path when a dark theme is used')),
+                                    type: 'string'
+                                }
+                            }
+                        }]
+                },
+                order: {
+                    description: ( localize(5375, 'Order in which this item should be displayed.')),
+                    type: 'integer'
+                },
+                alternativeIds: {
+                    description: ( localize(5376, 'Alternative identifiers for backward compatibility.')),
+                    type: 'array',
+                    items: {
+                        type: 'string'
+                    }
+                },
+                welcomeTitle: {
+                    description: ( localize(
+                        5377,
+                        'Title text to display in the chat welcome view for this session type.'
+                    )),
+                    type: 'string'
+                },
+                welcomeMessage: {
+                    description: ( localize(
+                        5378,
+                        'Message text (supports markdown) to display in the chat welcome view for this session type.'
+                    )),
+                    type: 'string'
+                },
+                welcomeTips: {
+                    description: ( localize(
+                        5379,
+                        'Tips text (supports markdown and theme icons) to display in the chat welcome view for this session type.'
+                    )),
+                    type: 'string'
+                },
+                inputPlaceholder: {
+                    description: ( localize(
+                        5380,
+                        'Placeholder text to display in the chat input box for this session type.'
+                    )),
                     type: 'string'
                 },
                 capabilities: {
-                    description: ( localize(5227, 'Optional capabilities for this chat session.')),
+                    description: ( localize(5381, 'Optional capabilities for this chat session.')),
                     type: 'object',
+                    additionalProperties: false,
                     properties: {
                         supportsFileAttachments: {
                             description: ( localize(
-                                5228,
+                                5382,
                                 'Whether this chat session supports attaching files or file references.'
                             )),
                             type: 'boolean'
                         },
                         supportsToolAttachments: {
                             description: ( localize(
-                                5229,
+                                5383,
                                 'Whether this chat session supports attaching tools or tool references.'
                             )),
                             type: 'boolean'
+                        },
+                        supportsMCPAttachments: {
+                            description: ( localize(5384, 'Whether this chat session supports attaching MCP resources.')),
+                            type: 'boolean'
+                        },
+                        supportsImageAttachments: {
+                            description: ( localize(5385, 'Whether this chat session supports attaching images.')),
+                            type: 'boolean'
+                        },
+                        supportsSearchResultAttachments: {
+                            description: ( localize(5386, 'Whether this chat session supports attaching search results.')),
+                            type: 'boolean'
+                        },
+                        supportsInstructionAttachments: {
+                            description: ( localize(5387, 'Whether this chat session supports attaching instructions.')),
+                            type: 'boolean'
+                        },
+                        supportsSourceControlAttachments: {
+                            description: ( localize(
+                                5388,
+                                'Whether this chat session supports attaching source control changes.'
+                            )),
+                            type: 'boolean'
+                        },
+                        supportsProblemAttachments: {
+                            description: ( localize(5389, 'Whether this chat session supports attaching problems.')),
+                            type: 'boolean'
+                        },
+                        supportsSymbolAttachments: {
+                            description: ( localize(5390, 'Whether this chat session supports attaching symbols.')),
+                            type: 'boolean'
                         }
                     }
                 },
                 commands: {
                     markdownDescription: ( localize(
-                        5230,
+                        5391,
                         "Commands available for this chat session, which the user can invoke with a `/`."
                     )),
                     type: 'array',
@@ -87,17 +195,17 @@ const extensionPoint = ExtensionsRegistry.registerExtensionPoint({
                         properties: {
                             name: {
                                 description: ( localize(
-                                    5231,
+                                    5392,
                                     "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(5232, "A description of this command.")),
+                                description: ( localize(5393, "A description of this command.")),
                                 type: 'string'
                             },
                             when: {
-                                description: ( localize(5233, "A condition which must be true to enable this command.")),
+                                description: ( localize(5394, "A condition which must be true to enable this command.")),
                                 type: 'string'
                             },
                         }
@@ -113,44 +221,66 @@ const extensionPoint = ExtensionsRegistry.registerExtensionPoint({
         }
     }
 });
-class ContributedChatSessionData {
-    constructor(session, chatSessionType, id, onWillDispose) {
+class ContributedChatSessionData extends Disposable {
+    getOption(optionId) {
+        return this._optionsCache.get(optionId);
+    }
+    setOption(optionId, value) {
+        this._optionsCache.set(optionId, value);
+    }
+    constructor(session, chatSessionType, resource, options, onWillDispose) {
+        super();
         this.session = session;
         this.chatSessionType = chatSessionType;
-        this.id = id;
+        this.resource = resource;
+        this.options = options;
         this.onWillDispose = onWillDispose;
-        this._disposableStore = ( new DisposableStore());
-        this._disposableStore.add(this.session.onWillDispose(() => {
-            this.onWillDispose(this.session, this.chatSessionType, this.id);
+        this._optionsCache = ( new Map());
+        if (options) {
+            for (const [key, value] of Object.entries(options)) {
+                this._optionsCache.set(key, value);
+            }
+        }
+        this._register(this.session.onWillDispose(() => {
+            this.onWillDispose(this.resource);
         }));
     }
-    dispose() {
-        this._disposableStore.dispose();
-    }
 }
 let ChatSessionsService = class ChatSessionsService extends Disposable {
     get onDidChangeInProgress() { return this._onDidChangeInProgress.event; }
-    constructor(_logService, _chatAgentService, _extensionService, _contextKeyService) {
+    get onDidChangeContentProviderSchemes() { return this._onDidChangeContentProviderSchemes.event; }
+    constructor(_logService, _chatAgentService, _extensionService, _contextKeyService, _menuService, _themeService, _labelService) {
         super();
         this._logService = _logService;
         this._chatAgentService = _chatAgentService;
         this._extensionService = _extensionService;
         this._contextKeyService = _contextKeyService;
+        this._menuService = _menuService;
+        this._themeService = _themeService;
+        this._labelService = _labelService;
         this._itemsProviders = ( new Map());
-        this._onDidChangeItemsProviders = this._register(( new Emitter()));
-        this.onDidChangeItemsProviders = this._onDidChangeItemsProviders.event;
-        this._contentProviders = ( new Map());
         this._contributions = ( new Map());
-        this._disposableStores = ( new Map());
+        this._contributionDisposables = this._register(( new DisposableMap()));
+        this._contentProviders = ( new Map());
+        this._alternativeIdMap = ( new Map());
         this._contextKeys = ( new Set());
+        this._onDidChangeItemsProviders = this._register(( new Emitter()));
+        this.onDidChangeItemsProviders = this._onDidChangeItemsProviders.event;
         this._onDidChangeSessionItems = this._register(( new Emitter()));
         this.onDidChangeSessionItems = this._onDidChangeSessionItems.event;
         this._onDidChangeAvailability = this._register(( new Emitter()));
         this.onDidChangeAvailability = this._onDidChangeAvailability.event;
         this._onDidChangeInProgress = this._register(( new Emitter()));
+        this._onDidChangeContentProviderSchemes = this._register(( new Emitter()));
         this.inProgressMap = ( new Map());
-        this._sessions = ( new Map());
-        this._editableSessions = ( new Map());
+        this._sessionTypeOptions = ( new Map());
+        this._sessionTypeIcons = ( new Map());
+        this._sessionTypeWelcomeTitles = ( new Map());
+        this._sessionTypeWelcomeMessages = ( new Map());
+        this._sessionTypeWelcomeTips = ( new Map());
+        this._sessionTypeInputPlaceholders = ( new Map());
+        this._sessions = ( new ResourceMap());
+        this._editableSessions = ( new ResourceMap());
         this._register(extensionPoint.setHandler(extensions => {
             for (const ext of extensions) {
                 if (!isProposedApiEnabled(ext.description, 'chatSessionsProvider')) {
@@ -160,17 +290,7 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
                     continue;
                 }
                 for (const contribution of ext.value) {
-                    const c = {
-                        type: contribution.type,
-                        name: contribution.name,
-                        displayName: contribution.displayName,
-                        description: contribution.description,
-                        when: contribution.when,
-                        capabilities: contribution.capabilities,
-                        extensionDescription: ext.description,
-                        commands: contribution.commands
-                    };
-                    this._register(this.registerContribution(c));
+                    this._register(this.registerContribution(contribution, ext.description));
                 }
             }
         }));
@@ -182,14 +302,22 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
                 this._logService.warn(`Failed to update progress status for '${chatSessionType}':`, error);
             });
         }));
+        this._register(this._labelService.registerFormatter({
+            scheme: Schemas.copilotPr,
+            formatting: {
+                label: '${authority}${path}',
+                separator: sep,
+                stripPathStartingSeparator: true,
+            }
+        }));
     }
     reportInProgress(chatSessionType, count) {
         let displayName;
-        if (chatSessionType === 'local') {
-            displayName = 'Local Chat Sessions';
+        if (chatSessionType === localChatSessionType) {
+            displayName = 'Local Chat Agent';
         }
         else {
-            displayName = this._contributions.get(chatSessionType)?.displayName;
+            displayName = this._contributions.get(chatSessionType)?.contribution.displayName;
         }
         if (displayName) {
             this.inProgressMap.set(displayName, count);
@@ -201,7 +329,7 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
     }
     async updateInProgressStatus(chatSessionType) {
         try {
-            const items = await this.provideChatSessionItems(chatSessionType, CancellationToken.None);
+            const items = await this.getChatSessionItems(chatSessionType, CancellationToken.None);
             const inProgress = items.filter(item => item.status === ChatSessionStatus.InProgress);
             this.reportInProgress(chatSessionType, inProgress.length);
         }
@@ -209,7 +337,7 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
             this._logService.warn(`Failed to update in-progress status for chat session type '${chatSessionType}':`, error);
         }
     }
-    registerContribution(contribution) {
+    registerContribution(contribution, ext) {
         if (( this._contributions.has(contribution.type))) {
             this._logService.warn(`Chat session contribution with id '${contribution.type}' is already registered.`);
             return { dispose: () => { } };
@@ -222,16 +350,61 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
                 }
             }
         }
-        this._contributions.set(contribution.type, contribution);
+        this._contributions.set(contribution.type, { contribution, extension: ext });
+        if (contribution.alternativeIds) {
+            for (const altId of contribution.alternativeIds) {
+                if (( this._alternativeIdMap.has(altId))) {
+                    this._logService.warn(`Alternative ID '${altId}' is already mapped to '${this._alternativeIdMap.get(altId)}'. Remapping to '${contribution.type}'.`);
+                }
+                this._alternativeIdMap.set(altId, contribution.type);
+            }
+        }
+        let icon;
+        if (contribution.icon) {
+            if (typeof contribution.icon === 'string') {
+                icon = contribution.icon.startsWith('$(') && contribution.icon.endsWith(')')
+                    ? ThemeIcon.fromString(contribution.icon)
+                    : ThemeIcon.fromId(contribution.icon);
+            }
+            else {
+                icon = {
+                    dark: joinPath(ext.extensionLocation, contribution.icon.dark),
+                    light: joinPath(ext.extensionLocation, contribution.icon.light)
+                };
+            }
+        }
+        if (icon) {
+            this._sessionTypeIcons.set(contribution.type, icon);
+        }
+        if (contribution.welcomeTitle) {
+            this._sessionTypeWelcomeTitles.set(contribution.type, contribution.welcomeTitle);
+        }
+        if (contribution.welcomeMessage) {
+            this._sessionTypeWelcomeMessages.set(contribution.type, contribution.welcomeMessage);
+        }
+        if (contribution.welcomeTips) {
+            this._sessionTypeWelcomeTips.set(contribution.type, contribution.welcomeTips);
+        }
+        if (contribution.inputPlaceholder) {
+            this._sessionTypeInputPlaceholders.set(contribution.type, contribution.inputPlaceholder);
+        }
         this._evaluateAvailability();
         return {
             dispose: () => {
                 this._contributions.delete(contribution.type);
-                const store = this._disposableStores.get(contribution.type);
-                if (store) {
-                    store.dispose();
-                    this._disposableStores.delete(contribution.type);
+                if (contribution.alternativeIds) {
+                    for (const altId of contribution.alternativeIds) {
+                        if (this._alternativeIdMap.get(altId) === contribution.type) {
+                            this._alternativeIdMap.delete(altId);
+                        }
+                    }
                 }
+                this._sessionTypeIcons.delete(contribution.type);
+                this._sessionTypeWelcomeTitles.delete(contribution.type);
+                this._sessionTypeWelcomeMessages.delete(contribution.type);
+                this._sessionTypeWelcomeTips.delete(contribution.type);
+                this._sessionTypeInputPlaceholders.delete(contribution.type);
+                this._contributionDisposables.deleteAndDispose(contribution.type);
             }
         };
     }
@@ -242,28 +415,77 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
         const whenExpr = ContextKeyExpr.deserialize(contribution.when);
         return !whenExpr || this._contextKeyService.contextMatchesRules(whenExpr);
     }
-    _registerMenuItems(contribution) {
-        return MenuRegistry.appendMenuItem(MenuId.ViewTitle, {
-            command: {
-                id: `${NEW_CHAT_SESSION_ACTION_ID}.${contribution.type}`,
-                title: ( localize(5234, "New {0} Chat Editor", contribution.displayName)),
+    _resolveToPrimaryType(sessionType) {
+        const contribution = this._contributions.get(sessionType)?.contribution;
+        if (contribution) {
+            if (this._isContributionAvailable(contribution)) {
+                return sessionType;
+            }
+        }
+        const primaryType = this._alternativeIdMap.get(sessionType);
+        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}'`);
+                return primaryType;
+            }
+        }
+        return undefined;
+    }
+    _registerMenuItems(contribution, extensionDescription) {
+        const contextKeyService = this._contextKeyService.createOverlay([
+            ['chatSessionType', contribution.type]
+        ]);
+        const rawMenuActions = this._menuService.getMenuActions(MenuId.ChatSessionsCreateSubMenu, contextKeyService);
+        const menuActions = ( rawMenuActions.map(value => value[1])).flat();
+        const whenClause = ( ContextKeyExpr.and(( ContextKeyExpr.equals('view', `${AGENT_SESSIONS_VIEWLET_ID}.${contribution.type}`))));
+        if (menuActions.length === 1) {
+            const first = menuActions[0];
+            if (first instanceof MenuItemAction) {
+                return 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, {
+                group: 'navigation',
+                title: ( localize(5395, "Create chat session")),
                 icon: Codicon.plus,
-                source: {
-                    id: contribution.extensionDescription.identifier.value,
-                    title: contribution.extensionDescription.displayName || contribution.extensionDescription.name,
-                }
-            },
-            group: 'navigation',
-            order: 1,
-            when: ( ContextKeyExpr.and(( ContextKeyExpr.equals('view', `${VIEWLET_ID}.${contribution.type}`)))),
-        });
+                order: 1,
+                when: whenClause,
+                submenu: MenuId.ChatSessionsCreateSubMenu,
+                isSplitButton: menuActions.length > 1
+            });
+        }
+        else {
+            return MenuRegistry.appendMenuItem(MenuId.ViewTitle, {
+                command: {
+                    id: `${NEW_CHAT_SESSION_ACTION_ID}.${contribution.type}`,
+                    title: ( localize(5396, "New {0}", contribution.displayName)),
+                    icon: Codicon.plus,
+                    source: {
+                        id: extensionDescription.identifier.value,
+                        title: extensionDescription.displayName || extensionDescription.name,
+                    }
+                },
+                group: 'navigation',
+                order: 1,
+                when: whenClause,
+            });
+        }
     }
     _registerCommands(contribution) {
         return registerAction2(class OpenNewChatSessionEditorAction extends Action2 {
             constructor() {
                 super({
                     id: `workbench.action.chat.openNewSessionEditor.${contribution.type}`,
-                    title: ( localize2(5234, "New {0} Chat Editor", contribution.displayName)),
+                    title: ( localize2(5396, "New {0}", contribution.displayName)),
                     category: CHAT_CATEGORY,
                     icon: Codicon.plus,
                     f1: true,
@@ -278,12 +500,15 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
                     const options = {
                         override: ChatEditorInput.EditorID,
                         pinned: true,
+                        title: {
+                            fallback: ( localize(5397, "{0}", contribution.displayName)),
+                        }
                     };
-                    const untitledId = `untitled-${generateUuid()}`;
-                    await editorService.openEditor({
-                        resource: ChatSessionUri.forSession(type, untitledId),
-                        options,
-                    });
+                    const resource = ( URI.from({
+                        scheme: type,
+                        path: `/untitled-${generateUuid()}`,
+                    }));
+                    await editorService.openEditor({ resource, options });
                 }
                 catch (e) {
                     logService.error(`Failed to open new '${type}' chat session editor`, e);
@@ -293,20 +518,16 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
     }
     _evaluateAvailability() {
         let hasChanges = false;
-        for (const contribution of ( this._contributions.values())) {
-            const isCurrentlyRegistered = ( this._disposableStores.has(contribution.type));
+        for (const { contribution, extension } of ( this._contributions.values())) {
+            const isCurrentlyRegistered = ( this._contributionDisposables.has(contribution.type));
             const shouldBeRegistered = this._isContributionAvailable(contribution);
             if (isCurrentlyRegistered && !shouldBeRegistered) {
-                const store = this._disposableStores.get(contribution.type);
-                if (store) {
-                    store.dispose();
-                    this._disposableStores.delete(contribution.type);
-                }
+                this._contributionDisposables.deleteAndDispose(contribution.type);
                 this._disposeSessionsForContribution(contribution.type);
                 hasChanges = true;
             }
             else if (!isCurrentlyRegistered && shouldBeRegistered) {
-                this._enableContribution(contribution);
+                this._enableContribution(contribution, extension);
                 hasChanges = true;
             }
         }
@@ -315,23 +536,23 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
             for (const provider of ( this._itemsProviders.values())) {
                 this._onDidChangeItemsProviders.fire(provider);
             }
-            for (const contribution of ( this._contributions.values())) {
+            for (const { contribution } of ( this._contributions.values())) {
                 this._onDidChangeSessionItems.fire(contribution.type);
             }
         }
     }
-    _enableContribution(contribution) {
+    _enableContribution(contribution, ext) {
         const disposableStore = ( new DisposableStore());
-        this._disposableStores.set(contribution.type, disposableStore);
-        disposableStore.add(this._registerAgent(contribution));
+        this._contributionDisposables.set(contribution.type, disposableStore);
+        disposableStore.add(this._registerAgent(contribution, ext));
         disposableStore.add(this._registerCommands(contribution));
-        disposableStore.add(this._registerMenuItems(contribution));
+        disposableStore.add(this._registerMenuItems(contribution, ext));
     }
     _disposeSessionsForContribution(contributionId) {
         const sessionsToDispose = [];
-        for (const [sessionKey, sessionData] of this._sessions) {
+        for (const [sessionResource, sessionData] of this._sessions) {
             if (sessionData.chatSessionType === contributionId) {
-                sessionsToDispose.push(sessionKey);
+                sessionsToDispose.push(sessionResource);
             }
         }
         if (sessionsToDispose.length > 0) {
@@ -344,9 +565,8 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
             }
         }
     }
-    _registerAgent(contribution) {
-        const { type: id, name, displayName, description, extensionDescription } = contribution;
-        const { identifier: extensionId, name: extensionName, displayName: extensionDisplayName, publisher: extensionPublisherId } = extensionDescription;
+    _registerAgent(contribution, ext) {
+        const { type: id, name, displayName, description } = contribution;
         const agentData = {
             id,
             name,
@@ -364,25 +584,30 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
                 isSticky: false,
             },
             capabilities: contribution.capabilities,
-            extensionId,
-            extensionVersion: extensionDescription.version,
-            extensionDisplayName: extensionDisplayName || extensionName,
-            extensionPublisherId,
+            extensionId: ext.identifier,
+            extensionVersion: ext.version,
+            extensionDisplayName: ext.displayName || ext.name,
+            extensionPublisherId: ext.publisher,
         };
         return this._chatAgentService.registerAgent(id, agentData);
     }
     getAllChatSessionContributions() {
-        return Array.from(( this._contributions.values())).filter(contribution => this._isContributionAvailable(contribution));
+        return Array.from(( this._contributions.values()), x => x.contribution)
+            .filter(contribution => this._isContributionAvailable(contribution));
     }
     getAllChatSessionItemProviders() {
         return [...( this._itemsProviders.values())].filter(provider => {
-            const contribution = this._contributions.get(provider.chatSessionType);
+            const contribution = this._contributions.get(provider.chatSessionType)?.contribution;
             return !contribution || this._isContributionAvailable(contribution);
         });
     }
-    async canResolveItemProvider(chatViewType) {
+    async hasChatSessionItemProvider(chatViewType) {
         await this._extensionService.whenInstalledExtensionsRegistered();
-        const contribution = this._contributions.get(chatViewType);
+        const resolvedType = this._resolveToPrimaryType(chatViewType);
+        if (resolvedType) {
+            chatViewType = resolvedType;
+        }
+        const contribution = this._contributions.get(chatViewType)?.contribution;
         if (contribution && !this._isContributionAvailable(contribution)) {
             return false;
         }
@@ -392,22 +617,35 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
         await this._extensionService.activateByEvent(`onChatSession:${chatViewType}`);
         return ( this._itemsProviders.has(chatViewType));
     }
-    async canResolveContentProvider(chatViewType) {
+    async canResolveChatSession(chatSessionResource) {
         await this._extensionService.whenInstalledExtensionsRegistered();
-        const contribution = this._contributions.get(chatViewType);
+        const resolvedType = this._resolveToPrimaryType(chatSessionResource.scheme) || chatSessionResource.scheme;
+        const contribution = this._contributions.get(resolvedType)?.contribution;
         if (contribution && !this._isContributionAvailable(contribution)) {
             return false;
         }
-        if (( this._contentProviders.has(chatViewType))) {
+        if (( this._contentProviders.has(chatSessionResource.scheme))) {
             return true;
         }
-        await this._extensionService.activateByEvent(`onChatSession:${chatViewType}`);
-        return ( this._contentProviders.has(chatViewType));
+        await this._extensionService.activateByEvent(`onChatSession:${chatSessionResource.scheme}`);
+        return ( this._contentProviders.has(chatSessionResource.scheme));
     }
-    async provideChatSessionItems(chatSessionType, token) {
-        if (!(await this.canResolveItemProvider(chatSessionType))) {
+    async getAllChatSessionItems(token) {
+        return Promise.all(Array.from(this.getAllChatSessionContributions(), async (contrib) => {
+            return {
+                chatSessionType: contrib.type,
+                items: await this.getChatSessionItems(contrib.type, token)
+            };
+        }));
+    }
+    async getChatSessionItems(chatSessionType, token) {
+        if (!(await this.hasChatSessionItemProvider(chatSessionType))) {
             return [];
         }
+        const resolvedType = this._resolveToPrimaryType(chatSessionType);
+        if (resolvedType) {
+            chatSessionType = resolvedType;
+        }
         const provider = this._itemsProviders.get(chatSessionType);
         if (provider?.provideChatSessionItems) {
             const sessions = await provider.provideChatSessionItems(token);
@@ -438,10 +676,15 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
         };
     }
     registerChatSessionContentProvider(chatSessionType, provider) {
+        if (( this._contentProviders.has(chatSessionType))) {
+            throw ( new Error(`Content provider for ${chatSessionType} is already registered.`));
+        }
         this._contentProviders.set(chatSessionType, provider);
+        this._onDidChangeContentProviderSchemes.fire({ added: [chatSessionType], removed: [] });
         return {
             dispose: () => {
                 this._contentProviders.delete(chatSessionType);
+                this._onDidChangeContentProviderSchemes.fire({ added: [], removed: [chatSessionType] });
                 for (const [key, session] of this._sessions) {
                     if (session.chatSessionType === chatSessionType) {
                         session.dispose();
@@ -451,10 +694,14 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
             }
         };
     }
-    async provideNewChatSessionItem(chatSessionType, options, token) {
-        if (!(await this.canResolveItemProvider(chatSessionType))) {
+    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`);
@@ -463,52 +710,125 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
         this._onDidChangeSessionItems.fire(chatSessionType);
         return chatSessionItem;
     }
-    async provideChatSessionContent(chatSessionType, id, token) {
-        if (!(await this.canResolveContentProvider(chatSessionType))) {
-            throw Error(`Can not find provider for ${chatSessionType}`);
-        }
-        const provider = this._contentProviders.get(chatSessionType);
-        if (!provider) {
-            throw Error(`Can not find provider for ${chatSessionType}`);
-        }
-        const sessionKey = `${chatSessionType}_${id}`;
-        const existingSessionData = this._sessions.get(sessionKey);
+    async getOrCreateChatSession(sessionResource, token) {
+        const existingSessionData = this._sessions.get(sessionResource);
         if (existingSessionData) {
             return existingSessionData.session;
         }
-        const session = await provider.provideChatSessionContent(id, token);
-        const sessionData = ( new ContributedChatSessionData(session, chatSessionType, id, this._onWillDisposeSession.bind(this)));
-        this._sessions.set(sessionKey, sessionData);
+        if (!(await raceCancellationError(this.canResolveChatSession(sessionResource), token))) {
+            throw Error(`Can not find provider for ${sessionResource}`);
+        }
+        const resolvedType = this._resolveToPrimaryType(sessionResource.scheme) || sessionResource.scheme;
+        const provider = this._contentProviders.get(resolvedType);
+        if (!provider) {
+            throw Error(`Can not find provider for ${sessionResource}`);
+        }
+        const session = await raceCancellationError(provider.provideChatSessionContent(sessionResource, token), token);
+        const sessionData = ( new ContributedChatSessionData(
+            session,
+            sessionResource.scheme,
+            sessionResource,
+            session.options,
+            resource => {
+                sessionData.dispose();
+                this._sessions.delete(resource);
+            }
+        ));
+        this._sessions.set(sessionResource, sessionData);
         return session;
     }
-    _onWillDisposeSession(session, chatSessionType, id) {
-        const sessionKey = `${chatSessionType}_${id}`;
-        this._sessions.delete(sessionKey);
+    hasAnySessionOptions(sessionResource) {
+        const session = this._sessions.get(sessionResource);
+        return !!session && !!session.options && ( Object.keys(session.options)).length > 0;
+    }
+    getSessionOption(sessionResource, optionId) {
+        const session = this._sessions.get(sessionResource);
+        return session?.getOption(optionId);
     }
-    async setEditableSession(sessionId, data) {
+    setSessionOption(sessionResource, optionId, value) {
+        const session = this._sessions.get(sessionResource);
+        return !!session?.setOption(optionId, value);
+    }
+    async setEditableSession(sessionResource, data) {
         if (!data) {
-            this._editableSessions.delete(sessionId);
+            this._editableSessions.delete(sessionResource);
         }
         else {
-            this._editableSessions.set(sessionId, data);
+            this._editableSessions.set(sessionResource, data);
         }
-        this._onDidChangeSessionItems.fire('local');
+        this._onDidChangeSessionItems.fire(localChatSessionType);
     }
-    getEditableData(sessionId) {
-        return this._editableSessions.get(sessionId);
+    getEditableData(sessionResource) {
+        return this._editableSessions.get(sessionResource);
     }
-    isEditable(sessionId) {
-        return ( this._editableSessions.has(sessionId));
+    isEditable(sessionResource) {
+        return ( this._editableSessions.has(sessionResource));
     }
     notifySessionItemsChanged(chatSessionType) {
         this._onDidChangeSessionItems.fire(chatSessionType);
     }
+    setOptionGroupsForSessionType(chatSessionType, handle, optionGroups) {
+        if (optionGroups) {
+            this._sessionTypeOptions.set(chatSessionType, optionGroups);
+        }
+        else {
+            this._sessionTypeOptions.delete(chatSessionType);
+        }
+    }
+    getOptionGroupsForSessionType(chatSessionType) {
+        return this._sessionTypeOptions.get(chatSessionType);
+    }
+    setOptionsChangeCallback(callback) {
+        this._optionsChangeCallback = callback;
+    }
+    async notifySessionOptionsChange(sessionResource, updates) {
+        if (!updates.length) {
+            return;
+        }
+        if (this._optionsChangeCallback) {
+            await this._optionsChangeCallback(sessionResource, updates);
+        }
+        for (const u of updates) {
+            this.setSessionOption(sessionResource, u.optionId, u.value);
+        }
+    }
+    getIconForSessionType(chatSessionType) {
+        const sessionTypeIcon = this._sessionTypeIcons.get(chatSessionType);
+        if (ThemeIcon.isThemeIcon(sessionTypeIcon)) {
+            return sessionTypeIcon;
+        }
+        if (isDark(this._themeService.getColorTheme().type)) {
+            return sessionTypeIcon?.dark;
+        }
+        else {
+            return sessionTypeIcon?.light;
+        }
+    }
+    getWelcomeTitleForSessionType(chatSessionType) {
+        return this._sessionTypeWelcomeTitles.get(chatSessionType);
+    }
+    getWelcomeMessageForSessionType(chatSessionType) {
+        return this._sessionTypeWelcomeMessages.get(chatSessionType);
+    }
+    getInputPlaceholderForSessionType(chatSessionType) {
+        return this._sessionTypeInputPlaceholders.get(chatSessionType);
+    }
+    getCapabilitiesForSessionType(chatSessionType) {
+        const contribution = this._contributions.get(chatSessionType)?.contribution;
+        return contribution?.capabilities;
+    }
+    getContentProviderSchemes() {
+        return Array.from(( this._contentProviders.keys()));
+    }
 };
 ChatSessionsService = ( __decorate([
     ( __param(0, ILogService)),
     ( __param(1, IChatAgentService)),
     ( __param(2, IExtensionService)),
-    ( __param(3, IContextKeyService))
+    ( __param(3, IContextKeyService)),
+    ( __param(4, IMenuService)),
+    ( __param(5, IThemeService)),
+    ( __param(6, ILabelService))
 ], ChatSessionsService));
 
 export { ChatSessionsService };