@codingame/monaco-vscode-chat-service-override 25.1.2 → 26.0.0

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

@@ -1,961 +0,0 @@
-
-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 { 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';
-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 { 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-api/vscode/vs/workbench/contrib/chat/browser/widgetHosts/editor/chatEditorInput';
-import { IChatAgentService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/participants/chatAgents.service';
-import { ChatContextKeys } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/actions/chatContextKeys';
-import { localChatSessionType, isSessionInProgressStatus } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService';
-import '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
-import { 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 { IChatToolInvocation } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService';
-import { IChatService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/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(5293, 'Contributes chat session integrations to the chat widget.')),
-        type: 'array',
-        items: {
-            type: 'object',
-            additionalProperties: false,
-            properties: {
-                type: {
-                    description: ( localize(5294, 'Unique identifier for the type of chat session.')),
-                    type: 'string',
-                },
-                name: {
-                    description: ( localize(
-                        5295,
-                        'Name of the dynamically registered chat participant (eg: @agent). Must not contain whitespace.'
-                    )),
-                    type: 'string',
-                    pattern: '^[\\w-]+$'
-                },
-                displayName: {
-                    description: ( localize(5296, 'A longer name for this item which is used for display in menus.')),
-                    type: 'string',
-                },
-                description: {
-                    description: ( localize(5297, 'Description of the chat session for use in menus and tooltips.')),
-                    type: 'string'
-                },
-                when: {
-                    description: ( localize(5298, 'Condition which must be true to show this item.')),
-                    type: 'string'
-                },
-                icon: {
-                    description: ( localize(
-                        5299,
-                        'Icon identifier (codicon ID) for the chat session editor tab. For example, "$(github)" or "$(cloud)".'
-                    )),
-                    anyOf: [{
-                            type: 'string'
-                        },
-                        {
-                            type: 'object',
-                            properties: {
-                                light: {
-                                    description: ( localize(5300, 'Icon path when a light theme is used')),
-                                    type: 'string'
-                                },
-                                dark: {
-                                    description: ( localize(5301, 'Icon path when a dark theme is used')),
-                                    type: 'string'
-                                }
-                            }
-                        }]
-                },
-                order: {
-                    description: ( localize(5302, 'Order in which this item should be displayed.')),
-                    type: 'integer'
-                },
-                alternativeIds: {
-                    description: ( localize(5303, 'Alternative identifiers for backward compatibility.')),
-                    type: 'array',
-                    items: {
-                        type: 'string'
-                    }
-                },
-                welcomeTitle: {
-                    description: ( localize(
-                        5304,
-                        'Title text to display in the chat welcome view for this session type.'
-                    )),
-                    type: 'string'
-                },
-                welcomeMessage: {
-                    description: ( localize(
-                        5305,
-                        'Message text (supports markdown) to display in the chat welcome view for this session type.'
-                    )),
-                    type: 'string'
-                },
-                welcomeTips: {
-                    description: ( localize(
-                        5306,
-                        'Tips text (supports markdown and theme icons) to display in the chat welcome view for this session type.'
-                    )),
-                    type: 'string'
-                },
-                inputPlaceholder: {
-                    description: ( localize(
-                        5307,
-                        'Placeholder text to display in the chat input box for this session type.'
-                    )),
-                    type: 'string'
-                },
-                capabilities: {
-                    description: ( localize(5308, 'Optional capabilities for this chat session.')),
-                    type: 'object',
-                    additionalProperties: false,
-                    properties: {
-                        supportsFileAttachments: {
-                            description: ( localize(
-                                5309,
-                                'Whether this chat session supports attaching files or file references.'
-                            )),
-                            type: 'boolean'
-                        },
-                        supportsToolAttachments: {
-                            description: ( localize(
-                                5310,
-                                'Whether this chat session supports attaching tools or tool references.'
-                            )),
-                            type: 'boolean'
-                        },
-                        supportsMCPAttachments: {
-                            description: ( localize(5311, 'Whether this chat session supports attaching MCP resources.')),
-                            type: 'boolean'
-                        },
-                        supportsImageAttachments: {
-                            description: ( localize(5312, 'Whether this chat session supports attaching images.')),
-                            type: 'boolean'
-                        },
-                        supportsSearchResultAttachments: {
-                            description: ( localize(5313, 'Whether this chat session supports attaching search results.')),
-                            type: 'boolean'
-                        },
-                        supportsInstructionAttachments: {
-                            description: ( localize(5314, 'Whether this chat session supports attaching instructions.')),
-                            type: 'boolean'
-                        },
-                        supportsSourceControlAttachments: {
-                            description: ( localize(
-                                5315,
-                                'Whether this chat session supports attaching source control changes.'
-                            )),
-                            type: 'boolean'
-                        },
-                        supportsProblemAttachments: {
-                            description: ( localize(5316, 'Whether this chat session supports attaching problems.')),
-                            type: 'boolean'
-                        },
-                        supportsSymbolAttachments: {
-                            description: ( localize(5317, 'Whether this chat session supports attaching symbols.')),
-                            type: 'boolean'
-                        }
-                    }
-                },
-                commands: {
-                    markdownDescription: ( localize(
-                        5318,
-                        "Commands available for this chat session, which the user can invoke with a `/`."
-                    )),
-                    type: 'array',
-                    items: {
-                        additionalProperties: false,
-                        type: 'object',
-                        defaultSnippets: [{ body: { name: '', description: '' } }],
-                        required: ['name'],
-                        properties: {
-                            name: {
-                                description: ( localize(
-                                    5319,
-                                    "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(5320, "A description of this command.")),
-                                type: 'string'
-                            },
-                            when: {
-                                description: ( localize(5321, "A condition which must be true to enable this command.")),
-                                type: 'string'
-                            },
-                        }
-                    }
-                },
-                canDelegate: {
-                    description: ( localize(
-                        5322,
-                        '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'],
-        }
-    },
-    activationEventsGenerator: function* (contribs) {
-        for (const contrib of contribs) {
-            yield `onChatSession:${contrib.type}`;
-        }
-    }
-});
-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.resource = resource;
-        this.options = options;
-        this.onWillDispose = onWillDispose;
-        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);
-        }));
-    }
-}
-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;
-        this._chatAgentService = _chatAgentService;
-        this._extensionService = _extensionService;
-        this._contextKeyService = _contextKeyService;
-        this._menuService = _menuService;
-        this._themeService = _themeService;
-        this._labelService = _labelService;
-        this._itemsProviders = ( new Map());
-        this._contributions = ( 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._onDidChangeSessionOptions = this._register(( new Emitter()));
-        this._onDidChangeOptionGroups = this._register(( new Emitter()));
-        this.inProgressMap = ( 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._hasCanDelegateProvidersKey = ChatContextKeys.hasCanDelegateProviders.bindTo(this._contextKeyService);
-        this._register(extensionPoint.setHandler(extensions => {
-            for (const ext of extensions) {
-                if (!isProposedApiEnabled(ext.description, 'chatSessionsProvider')) {
-                    continue;
-                }
-                if (!Array.isArray(ext.value)) {
-                    continue;
-                }
-                for (const contribution of ext.value) {
-                    this._register(this.registerContribution(contribution, ext.description));
-                }
-            }
-        }));
-        this._register(Event.filter(this._contextKeyService.onDidChangeContext, e => e.affectsSome(this._contextKeys))(() => {
-            this._evaluateAvailability();
-        }));
-        this._register(this.onDidChangeSessionItems(chatSessionType => {
-            this.updateInProgressStatus(chatSessionType).catch(error => {
-                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 === localChatSessionType) {
-            displayName = 'Local Chat Agent';
-        }
-        else {
-            displayName = this._contributions.get(chatSessionType)?.contribution.displayName;
-        }
-        if (displayName) {
-            this.inProgressMap.set(displayName, count);
-        }
-        this._onDidChangeInProgress.fire();
-    }
-    getInProgress() {
-        return ( Array.from(this.inProgressMap.entries()).map(([displayName, count]) => ({ displayName, count })));
-    }
-    async updateInProgressStatus(chatSessionType) {
-        try {
-            const items = await this.getChatSessionItems(chatSessionType, CancellationToken.None);
-            const inProgress = items.filter(item => item.status && isSessionInProgressStatus(item.status));
-            this.reportInProgress(chatSessionType, inProgress.length);
-        }
-        catch (error) {
-            this._logService.warn(`Failed to update in-progress status for chat session type '${chatSessionType}':`, error);
-        }
-    }
-    registerContribution(contribution, ext) {
-        if (( this._contributions.has(contribution.type))) {
-            return { dispose: () => { } };
-        }
-        if (contribution.when) {
-            const whenExpr = ContextKeyExpr.deserialize(contribution.when);
-            if (whenExpr) {
-                for (const key of ( whenExpr.keys())) {
-                    this._contextKeys.add(key);
-                }
-            }
-        }
-        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);
-                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);
-                this._updateHasCanDelegateProvidersContextKey();
-            }
-        };
-    }
-    _isContributionAvailable(contribution) {
-        if (!contribution.when) {
-            return true;
-        }
-        const whenExpr = ContextKeyExpr.deserialize(contribution.when);
-        return !whenExpr || this._contextKeyService.contextMatchesRules(whenExpr);
-    }
-    _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)) {
-                return primaryType;
-            }
-        }
-        return undefined;
-    }
-    _registerMenuItems(contribution, extensionDescription) {
-        const contextKeyService = this._contextKeyService.createOverlay([
-            ['chatSessionType', contribution.type]
-        ]);
-        const rawMenuActions = this._menuService.getMenuActions(MenuId.AgentSessionsCreateSubMenu, contextKeyService);
-        const menuActions = ( rawMenuActions.map(value => value[1])).flat();
-        const disposables = ( new DisposableStore());
-        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 combinedDisposable(registerAction2(class OpenChatSessionAction extends Action2 {
-            constructor() {
-                super({
-                    id: `workbench.action.chat.openSessionWithPrompt.${contribution.type}`,
-                    title: ( localize2(5323, "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(5324, "New {0}", contribution.displayName)),
-                    category: CHAT_CATEGORY,
-                    icon: Codicon.plus,
-                    f1: true,
-                    precondition: ChatContextKeys.enabled,
-                });
-            }
-            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(5325, "{0}", contribution.displayName)),
-                        }
-                    };
-                    const resource = ( URI.from({
-                        scheme: type,
-                        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(5326, "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;
-        for (const { contribution, extension } of ( this._contributions.values())) {
-            const isCurrentlyRegistered = ( this._contributionDisposables.has(contribution.type));
-            const shouldBeRegistered = this._isContributionAvailable(contribution);
-            if (isCurrentlyRegistered && !shouldBeRegistered) {
-                this._contributionDisposables.deleteAndDispose(contribution.type);
-                this._disposeSessionsForContribution(contribution.type);
-                hasChanges = true;
-            }
-            else if (!isCurrentlyRegistered && shouldBeRegistered) {
-                this._enableContribution(contribution, extension);
-                hasChanges = true;
-            }
-        }
-        if (hasChanges) {
-            this._onDidChangeAvailability.fire();
-            for (const provider of ( this._itemsProviders.values())) {
-                this._onDidChangeItemsProviders.fire(provider);
-            }
-            for (const { contribution } of ( this._contributions.values())) {
-                this._onDidChangeSessionItems.fire(contribution.type);
-            }
-        }
-        this._updateHasCanDelegateProvidersContextKey();
-    }
-    _enableContribution(contribution, ext) {
-        const disposableStore = ( new DisposableStore());
-        this._contributionDisposables.set(contribution.type, disposableStore);
-        if (contribution.canDelegate) {
-            disposableStore.add(this._registerAgent(contribution, ext));
-            disposableStore.add(this._registerCommands(contribution));
-        }
-        disposableStore.add(this._registerMenuItems(contribution, ext));
-    }
-    _disposeSessionsForContribution(contributionId) {
-        const sessionsToDispose = [];
-        for (const [sessionResource, sessionData] of this._sessions) {
-            if (sessionData.chatSessionType === contributionId) {
-                sessionsToDispose.push(sessionResource);
-            }
-        }
-        if (sessionsToDispose.length > 0) {
-            this._logService.info(`Disposing ${sessionsToDispose.length} cached sessions for contribution '${contributionId}' due to when clause change`);
-        }
-        for (const sessionKey of sessionsToDispose) {
-            const sessionData = this._sessions.get(sessionKey);
-            if (sessionData) {
-                sessionData.dispose();
-            }
-        }
-    }
-    _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,
-            fullName: displayName,
-            description: description,
-            isDefault: false,
-            isCore: false,
-            isDynamic: true,
-            slashCommands: contribution.commands ?? [],
-            locations: [ChatAgentLocation.Chat],
-            modes: [ChatModeKind.Agent, ChatModeKind.Ask],
-            disambiguation: [],
-            metadata: {
-                ...icons,
-            },
-            capabilities: contribution.capabilities,
-            canAccessPreviousChatHistory: true,
-            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()), x => x.contribution)
-            .filter(contribution => this._isContributionAvailable(contribution));
-    }
-    _updateHasCanDelegateProvidersContextKey() {
-        const hasCanDelegate = this.getAllChatSessionContributions().filter(c => c.canDelegate);
-        const canDelegateEnabled = hasCanDelegate.length > 0;
-        this._logService.trace(`[ChatSessionsService] hasCanDelegateProvidersAvailable=${canDelegateEnabled} (${( hasCanDelegate.map(c => c.type)).join(', ')})`);
-        this._hasCanDelegateProvidersKey.set(canDelegateEnabled);
-    }
-    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 activateChatSessionItemProvider(chatViewType) {
-        await this._extensionService.whenInstalledExtensionsRegistered();
-        const resolvedType = this._resolveToPrimaryType(chatViewType);
-        if (resolvedType) {
-            chatViewType = resolvedType;
-        }
-        const contribution = this._contributions.get(chatViewType)?.contribution;
-        if (contribution && !this._isContributionAvailable(contribution)) {
-            return undefined;
-        }
-        if (( this._itemsProviders.has(chatViewType))) {
-            return this._itemsProviders.get(chatViewType);
-        }
-        await this._extensionService.activateByEvent(`onChatSession:${chatViewType}`);
-        return this._itemsProviders.get(chatViewType);
-    }
-    async canResolveChatSession(chatSessionResource) {
-        await this._extensionService.whenInstalledExtensionsRegistered();
-        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(chatSessionResource.scheme))) {
-            return true;
-        }
-        await this._extensionService.activateByEvent(`onChatSession:${chatSessionResource.scheme}`);
-        return ( this._contentProviders.has(chatSessionResource.scheme));
-    }
-    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.activateChatSessionItemProvider(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);
-            return sessions;
-        }
-        return [];
-    }
-    registerChatSessionItemProvider(provider) {
-        const chatSessionType = provider.chatSessionType;
-        this._itemsProviders.set(chatSessionType, provider);
-        this._onDidChangeItemsProviders.fire(provider);
-        const disposables = ( new DisposableStore());
-        disposables.add(provider.onDidChangeChatSessionItems(() => {
-            this._onDidChangeSessionItems.fire(chatSessionType);
-        }));
-        this.updateInProgressStatus(chatSessionType).catch(error => {
-            this._logService.warn(`Failed to update initial progress status for '${chatSessionType}':`, error);
-        });
-        return {
-            dispose: () => {
-                disposables.dispose();
-                const provider = this._itemsProviders.get(chatSessionType);
-                if (provider) {
-                    this._itemsProviders.delete(chatSessionType);
-                    this._onDidChangeItemsProviders.fire(provider);
-                }
-            }
-        };
-    }
-    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();
-                        this._sessions.delete(key);
-                    }
-                }
-            }
-        };
-    }
-    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(5327, "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(5328, 'Thinking...'));
-            }
-        }
-        return renderAsPlaintext(description, { useLinkFormatter: true });
-    }
-    async getOrCreateChatSession(sessionResource, token) {
-        const existingSessionData = this._sessions.get(sessionResource);
-        if (existingSessionData) {
-            return existingSessionData.session;
-        }
-        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;
-    }
-    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);
-    }
-    setSessionOption(sessionResource, optionId, value) {
-        const session = this._sessions.get(sessionResource);
-        return !!session?.setOption(optionId, value);
-    }
-    notifySessionItemsChanged(chatSessionType) {
-        this._onDidChangeSessionItems.fire(chatSessionType);
-    }
-    setOptionGroupsForSessionType(chatSessionType, handle, optionGroups) {
-        if (optionGroups) {
-            this._sessionTypeOptions.set(chatSessionType, optionGroups);
-        }
-        else {
-            this._sessionTypeOptions.delete(chatSessionType);
-        }
-        this._onDidChangeOptionGroups.fire(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);
-        }
-        this._onDidChangeSessionOptions.fire(sessionResource);
-    }
-    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(4, IMenuService)),
-    ( __param(5, IThemeService)),
-    ( __param(6, ILabelService))
-], ChatSessionsService));
-
-export { ChatSessionsService };