@codingame/monaco-vscode-chat-service-override 19.1.4 → 20.0.0

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

@@ -23,9 +23,9 @@ import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/mini
 import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/miscColors';
 import { quickInputBackground, quickInputForeground } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/quickpickColors';
 import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/searchColors';
-import { showChatView } from '@codingame/monaco-vscode-9911aec2-e4dd-5483-8369-9d695cc70d8a-common/vscode/vs/workbench/contrib/chat/browser/chat';
-import { ChatWidget } from '@codingame/monaco-vscode-c465110a-57c0-59d7-a6b2-be0a4db7e517-common/vscode/vs/workbench/contrib/chat/browser/chatWidget';
-import { isCellTextEditOperation } from '@codingame/monaco-vscode-9911aec2-e4dd-5483-8369-9d695cc70d8a-common/vscode/vs/workbench/contrib/chat/common/chatModel';
+import { showChatView } from '@codingame/monaco-vscode-b994942c-360d-5b68-8a33-77d4bde6b714-common/vscode/vs/workbench/contrib/chat/browser/chat';
+import { ChatWidget } from '@codingame/monaco-vscode-e28ac690-06d5-5ee9-92d1-02df70296354-common/vscode/vs/workbench/contrib/chat/browser/chatWidget';
+import { isCellTextEditOperation } from '@codingame/monaco-vscode-c2deffc4-ad68-5e63-8f95-9b89e0fc6898-common/vscode/vs/workbench/contrib/chat/common/chatModel';
 import { IChatService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService.service';
 import { IViewsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/views/common/viewsService.service';
 import { EDITOR_DRAG_AND_DROP_BACKGROUND } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/theme';

package/vscode/src/vs/workbench/contrib/chat/browser/chatResponseAccessibleView.d.ts

@@ -3,7 +3,7 @@ import { AccessibleViewProviderId, AccessibleViewType, IAccessibleViewContentPro
 import { IAccessibleViewImplementation } from "@codingame/monaco-vscode-api/vscode/vs/platform/accessibility/browser/accessibleViewRegistry";
 import { ServicesAccessor } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
 import { AccessibilityVerbositySettingId } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/accessibility/browser/accessibilityConfiguration";
-import { ChatTreeItem, IChatWidget } from "@codingame/monaco-vscode-9911aec2-e4dd-5483-8369-9d695cc70d8a-common/vscode/vs/workbench/contrib/chat/browser/chat";
+import { ChatTreeItem, IChatWidget } from "@codingame/monaco-vscode-b994942c-360d-5b68-8a33-77d4bde6b714-common/vscode/vs/workbench/contrib/chat/browser/chat";
 export declare class ChatResponseAccessibleView implements IAccessibleViewImplementation {
     readonly priority = 100;
     readonly name = "panelChat";

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

@@ -1,12 +1,13 @@
 
-import { renderMarkdownAsPlaintext } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/markdownRenderer';
-import { MarkdownString } from '@codingame/monaco-vscode-api/vscode/vs/base/common/htmlContent';
+import { renderAsPlaintext } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/markdownRenderer';
+import { isMarkdownString, MarkdownString } from '@codingame/monaco-vscode-api/vscode/vs/base/common/htmlContent';
 import { stripIcons } from '@codingame/monaco-vscode-api/vscode/vs/base/common/iconLabels';
 import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
 import { AccessibleViewType, AccessibleViewProviderId } from '@codingame/monaco-vscode-api/vscode/vs/platform/accessibility/browser/accessibleView';
 import { AccessibilityVerbositySettingId } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/accessibility/browser/accessibilityConfiguration';
+import { migrateLegacyTerminalToolSpecificData } from '@codingame/monaco-vscode-e28ac690-06d5-5ee9-92d1-02df70296354-common/vscode/vs/workbench/contrib/chat/common/chat';
 import { ChatContextKeys } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatContextKeys';
-import { isResponseVM } from '@codingame/monaco-vscode-9911aec2-e4dd-5483-8369-9d695cc70d8a-common/vscode/vs/workbench/contrib/chat/common/chatViewModel';
+import { isResponseVM } from '@codingame/monaco-vscode-c2deffc4-ad68-5e63-8f95-9b89e0fc6898-common/vscode/vs/workbench/contrib/chat/common/chatViewModel';
 import { IChatWidgetService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service';
 
 class ChatResponseAccessibleView {
@@ -53,18 +54,42 @@ class ChatResponseAccessibleProvider extends Disposable {
             responseContent = item.errorDetails.message;
         }
         if (isResponseVM(item)) {
+            item.response.value.filter(item => item.kind === 'elicitation').forEach(elicitation => {
+                const title = elicitation.title;
+                if (typeof title === 'string') {
+                    responseContent += `${title}\n`;
+                }
+                else if (isMarkdownString(title)) {
+                    responseContent += renderAsPlaintext(title, { includeCodeBlocksFences: true }) + '\n';
+                }
+                const message = elicitation.message;
+                if (isMarkdownString(message)) {
+                    responseContent += renderAsPlaintext(message, { includeCodeBlocksFences: true });
+                }
+                else {
+                    responseContent += message;
+                }
+            });
             const toolInvocations = item.response.value.filter(item => item.kind === 'toolInvocation');
             for (const toolInvocation of toolInvocations) {
                 if (toolInvocation.confirmationMessages) {
                     const title = typeof toolInvocation.confirmationMessages.title === 'string' ? toolInvocation.confirmationMessages.title : toolInvocation.confirmationMessages.title.value;
-                    const message = typeof toolInvocation.confirmationMessages.message === 'string' ? toolInvocation.confirmationMessages.message : stripIcons(renderMarkdownAsPlaintext(toolInvocation.confirmationMessages.message));
+                    const message = typeof toolInvocation.confirmationMessages.message === 'string' ? toolInvocation.confirmationMessages.message : stripIcons(renderAsPlaintext(toolInvocation.confirmationMessages.message));
                     let input = '';
                     if (toolInvocation.toolSpecificData) {
-                        input = toolInvocation.toolSpecificData?.kind === 'terminal'
-                            ? toolInvocation.toolSpecificData.command
-                            : input = toolInvocation.toolSpecificData?.kind === 'extensions'
+                        if (toolInvocation.toolSpecificData?.kind === 'terminal') {
+                            const terminalData = migrateLegacyTerminalToolSpecificData(toolInvocation.toolSpecificData);
+                            input = terminalData.commandLine.userEdited ?? terminalData.commandLine.toolEdited ?? terminalData.commandLine.original;
+                        }
+                        else {
+                            input = toolInvocation.toolSpecificData?.kind === 'extensions'
                                 ? JSON.stringify(toolInvocation.toolSpecificData.extensions)
-                                : JSON.stringify(toolInvocation.toolSpecificData.rawInput);
+                                : toolInvocation.toolSpecificData?.kind === 'todoList'
+                                    ? JSON.stringify(toolInvocation.toolSpecificData.todoList)
+                                    : toolInvocation.toolSpecificData?.kind === 'pullRequest'
+                                        ? JSON.stringify(toolInvocation.toolSpecificData)
+                                        : JSON.stringify(toolInvocation.toolSpecificData.rawInput);
+                        }
                     }
                     responseContent += `${title}`;
                     if (input) {
@@ -74,19 +99,19 @@ class ChatResponseAccessibleProvider extends Disposable {
                 }
                 else if (toolInvocation.isComplete && toolInvocation.resultDetails && 'input' in toolInvocation.resultDetails) {
                     responseContent += '\n' + toolInvocation.resultDetails.isError ? 'Errored ' : 'Completed ';
-                    responseContent += `${`${typeof toolInvocation.invocationMessage === 'string' ? toolInvocation.invocationMessage : stripIcons(renderMarkdownAsPlaintext(toolInvocation.invocationMessage))} with input: ${toolInvocation.resultDetails.input}`}\n`;
+                    responseContent += `${`${typeof toolInvocation.invocationMessage === 'string' ? toolInvocation.invocationMessage : stripIcons(renderAsPlaintext(toolInvocation.invocationMessage))} with input: ${toolInvocation.resultDetails.input}`}\n`;
                 }
             }
             const pastConfirmations = item.response.value.filter(item => item.kind === 'toolInvocationSerialized');
             for (const pastConfirmation of pastConfirmations) {
                 if (pastConfirmation.isComplete && pastConfirmation.resultDetails && 'input' in pastConfirmation.resultDetails) {
                     if (pastConfirmation.pastTenseMessage) {
-                        responseContent += `\n${`${typeof pastConfirmation.pastTenseMessage === 'string' ? pastConfirmation.pastTenseMessage : stripIcons(renderMarkdownAsPlaintext(pastConfirmation.pastTenseMessage))} with input: ${pastConfirmation.resultDetails.input}`}\n`;
+                        responseContent += `\n${`${typeof pastConfirmation.pastTenseMessage === 'string' ? pastConfirmation.pastTenseMessage : stripIcons(renderAsPlaintext(pastConfirmation.pastTenseMessage))} with input: ${pastConfirmation.resultDetails.input}`}\n`;
                     }
                 }
             }
         }
-        return renderMarkdownAsPlaintext(( new MarkdownString(responseContent)), true);
+        return renderAsPlaintext(( new MarkdownString(responseContent)), { includeCodeBlocksFences: true });
     }
     onClose() {
         this._widget.reveal(this._focusedItem);

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

@@ -0,0 +1,49 @@
+import { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
+import { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
+import { Disposable, IDisposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IContextKeyService } from "@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service";
+import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
+import { IExtensionService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extensions.service";
+import { IChatAgentService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatAgents.service";
+import { ChatSession, IChatSessionContentProvider, IChatSessionItem, IChatSessionItemProvider, IChatSessionsExtensionPoint } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService";
+import { IChatSessionsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService.service";
+export declare class ChatSessionsService extends Disposable implements IChatSessionsService {
+    private readonly _logService;
+    private readonly _instantiationService;
+    private readonly _chatAgentService;
+    private readonly _extensionService;
+    private readonly _contextKeyService;
+    readonly _serviceBrand: undefined;
+    private readonly _itemsProviders;
+    private readonly _onDidChangeItemsProviders;
+    readonly onDidChangeItemsProviders: Event<IChatSessionItemProvider>;
+    private readonly _contentProviders;
+    private readonly _contributions;
+    private readonly _dynamicAgentDisposables;
+    private readonly _contextKeys;
+    private readonly _onDidChangeSessionItems;
+    readonly onDidChangeSessionItems: Event<string>;
+    private readonly _onDidChangeAvailability;
+    readonly onDidChangeAvailability: Event<void>;
+    constructor(_logService: ILogService, _instantiationService: IInstantiationService, _chatAgentService: IChatAgentService, _extensionService: IExtensionService, _contextKeyService: IContextKeyService);
+    registerContribution(contribution: IChatSessionsExtensionPoint): IDisposable;
+    private _isContributionAvailable;
+    private _registerDynamicAgentIfAvailable;
+    private _disposeDynamicAgent;
+    private _evaluateAvailability;
+    private _disposeSessionsForContribution;
+    private _registerDynamicAgent;
+    getChatSessionContributions(): IChatSessionsExtensionPoint[];
+    getChatSessionItemProviders(): IChatSessionItemProvider[];
+    canResolveItemProvider(chatViewType: string): Promise<boolean>;
+    notifySessionItemsChange(chatSessionType: string): void;
+    canResolveContentProvider(chatViewType: string): Promise<boolean>;
+    provideChatSessionItems(chatSessionType: string, token: CancellationToken): Promise<IChatSessionItem[]>;
+    registerChatSessionItemProvider(provider: IChatSessionItemProvider): IDisposable;
+    registerChatSessionContentProvider(provider: IChatSessionContentProvider): IDisposable;
+    private readonly _sessions;
+    provideChatSessionContent(chatSessionType: string, id: string, token: CancellationToken): Promise<ChatSession>;
+    private _onWillDisposeSession;
+    get hasChatSessionItemProviders(): boolean;
+}

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

@@ -0,0 +1,407 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+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 { MarkdownString } from '@codingame/monaco-vscode-api/vscode/vs/base/common/htmlContent';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+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 { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
+import { IEditorGroupsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorGroupsService.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 { IChatWidgetService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service';
+import { ChatEditorInput } from '@codingame/monaco-vscode-b994942c-360d-5b68-8a33-77d4bde6b714-common/vscode/vs/workbench/contrib/chat/browser/chatEditorInput';
+import { IChatAgentService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatAgents.service';
+import { IChatService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService.service';
+import { IChatSessionsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService.service';
+import { ChatSessionUri } from '@codingame/monaco-vscode-b994942c-360d-5b68-8a33-77d4bde6b714-common/vscode/vs/workbench/contrib/chat/common/chatUri';
+import { ChatModeKind, ChatAgentLocation } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
+
+const CODING_AGENT_DOCS = 'https://code.visualstudio.com/docs/copilot/copilot-coding-agent';
+const extensionPoint = ExtensionsRegistry.registerExtensionPoint({
+    extensionPoint: 'chatSessions',
+    jsonSchema: {
+        description: ( localize(5073, 'Contributes chat session integrations to the chat widget.')),
+        type: 'array',
+        items: {
+            type: 'object',
+            properties: {
+                type: {
+                    description: ( localize(5074, 'Unique identifier for the type of chat session.')),
+                    type: 'string',
+                },
+                name: {
+                    description: ( localize(5075, 'Name shown in the chat widget. (eg: @agent)')),
+                    type: 'string',
+                },
+                displayName: {
+                    description: ( localize(5076, 'A longer name for this item which is used for display in menus.')),
+                    type: 'string',
+                },
+                description: {
+                    description: ( localize(5077, 'Description of the chat session for use in menus and tooltips.')),
+                    type: 'string'
+                },
+                when: {
+                    description: ( localize(5078, 'Condition which must be true to show this item.')),
+                    type: 'string'
+                }
+            },
+            required: ['id', 'name', 'displayName', 'description'],
+        }
+    },
+    activationEventsGenerator: (contribs, results) => {
+        for (const contrib of contribs) {
+            results.push(`onChatSession:${contrib.type}`);
+        }
+    }
+});
+class ContributedChatSessionData {
+    constructor(session, chatSessionType, id, onWillDispose) {
+        this.session = session;
+        this.chatSessionType = chatSessionType;
+        this.id = id;
+        this.onWillDispose = onWillDispose;
+        this._disposableStore = ( new DisposableStore());
+        this._disposableStore.add(this.session.onWillDispose(() => {
+            this.onWillDispose(this.session, this.chatSessionType, this.id);
+        }));
+    }
+    dispose() {
+        this._disposableStore.dispose();
+    }
+}
+let ChatSessionsService = class ChatSessionsService extends Disposable {
+    constructor(_logService, _instantiationService, _chatAgentService, _extensionService, _contextKeyService) {
+        super();
+        this._logService = _logService;
+        this._instantiationService = _instantiationService;
+        this._chatAgentService = _chatAgentService;
+        this._extensionService = _extensionService;
+        this._contextKeyService = _contextKeyService;
+        this._itemsProviders = ( new Map());
+        this._onDidChangeItemsProviders = this._register(( new Emitter()));
+        this.onDidChangeItemsProviders = this._onDidChangeItemsProviders.event;
+        this._contentProviders = ( new Map());
+        this._contributions = ( new Map());
+        this._dynamicAgentDisposables = ( new Map());
+        this._contextKeys = ( new Set());
+        this._onDidChangeSessionItems = this._register(( new Emitter()));
+        this.onDidChangeSessionItems = this._onDidChangeSessionItems.event;
+        this._onDidChangeAvailability = this._register(( new Emitter()));
+        this.onDidChangeAvailability = this._onDidChangeAvailability.event;
+        this._sessions = ( new Map());
+        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) {
+                    const c = {
+                        id: contribution.id,
+                        type: contribution.type,
+                        name: contribution.name,
+                        displayName: contribution.displayName,
+                        description: contribution.description,
+                        when: contribution.when,
+                        extensionDescription: ext.description,
+                    };
+                    this._logService.info(`Registering chat session from extension contribution: ${c.displayName} (id='${c.type}' name='${c.name}')`);
+                    this._register(this.registerContribution(c));
+                }
+            }
+        }));
+        this._register(Event.filter(this._contextKeyService.onDidChangeContext, e => e.affectsSome(this._contextKeys))(() => {
+            this._evaluateAvailability();
+        }));
+    }
+    registerContribution(contribution) {
+        if (( this._contributions.has(contribution.type))) {
+            this._logService.warn(`Chat session contribution with id '${contribution.type}' is already registered.`);
+            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);
+        this._registerDynamicAgentIfAvailable(contribution);
+        return {
+            dispose: () => {
+                this._contributions.delete(contribution.type);
+                this._disposeDynamicAgent(contribution.type);
+            }
+        };
+    }
+    _isContributionAvailable(contribution) {
+        if (!contribution.when) {
+            return true;
+        }
+        const whenExpr = ContextKeyExpr.deserialize(contribution.when);
+        return !whenExpr || this._contextKeyService.contextMatchesRules(whenExpr);
+    }
+    _registerDynamicAgentIfAvailable(contribution) {
+        if (this._isContributionAvailable(contribution)) {
+            const disposable = this._registerDynamicAgent(contribution);
+            this._dynamicAgentDisposables.set(contribution.type, disposable);
+        }
+    }
+    _disposeDynamicAgent(contributionId) {
+        const disposable = this._dynamicAgentDisposables.get(contributionId);
+        if (disposable) {
+            disposable.dispose();
+            this._dynamicAgentDisposables.delete(contributionId);
+        }
+    }
+    _evaluateAvailability() {
+        let hasChanges = false;
+        for (const contribution of ( this._contributions.values())) {
+            const isCurrentlyRegistered = ( this._dynamicAgentDisposables.has(contribution.type));
+            const shouldBeRegistered = this._isContributionAvailable(contribution);
+            if (isCurrentlyRegistered && !shouldBeRegistered) {
+                this._disposeDynamicAgent(contribution.type);
+                this._disposeSessionsForContribution(contribution.type);
+                hasChanges = true;
+            }
+            else if (!isCurrentlyRegistered && shouldBeRegistered) {
+                this._registerDynamicAgentIfAvailable(contribution);
+                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);
+            }
+        }
+    }
+    _disposeSessionsForContribution(contributionId) {
+        const sessionsToDispose = [];
+        for (const [sessionKey, sessionData] of this._sessions) {
+            if (sessionData.chatSessionType === contributionId) {
+                sessionsToDispose.push(sessionKey);
+            }
+        }
+        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();
+            }
+        }
+    }
+    _registerDynamicAgent(contribution) {
+        const { type: id, name, displayName, description, extensionDescription } = contribution;
+        const { identifier: extensionId, name: extensionName, displayName: extensionDisplayName, publisher: extensionPublisherId } = extensionDescription;
+        const agentData = {
+            id,
+            name,
+            fullName: displayName,
+            description: description,
+            isDefault: false,
+            isCore: false,
+            isDynamic: true,
+            isCodingAgent: true,
+            slashCommands: [],
+            locations: [ChatAgentLocation.Panel],
+            modes: [ChatModeKind.Agent, ChatModeKind.Ask],
+            disambiguation: [],
+            metadata: {
+                themeIcon: Codicon.sendToRemoteAgent,
+                isSticky: false,
+            },
+            extensionId,
+            extensionDisplayName: extensionDisplayName || extensionName,
+            extensionPublisherId,
+        };
+        const agentImpl = this._instantiationService.createInstance(CodingAgentChatImplementation, contribution);
+        const disposable = this._chatAgentService.registerDynamicAgent(agentData, agentImpl);
+        return disposable;
+    }
+    getChatSessionContributions() {
+        return Array.from(( this._contributions.values())).filter(contribution => this._isContributionAvailable(contribution));
+    }
+    getChatSessionItemProviders() {
+        return [...( this._itemsProviders.values())].filter(provider => {
+            const contribution = this._contributions.get(provider.chatSessionType);
+            return !contribution || this._isContributionAvailable(contribution);
+        });
+    }
+    async canResolveItemProvider(chatViewType) {
+        await this._extensionService.whenInstalledExtensionsRegistered();
+        const contribution = this._contributions.get(chatViewType);
+        if (contribution && !this._isContributionAvailable(contribution)) {
+            return false;
+        }
+        if (( this._itemsProviders.has(chatViewType))) {
+            return true;
+        }
+        await this._extensionService.activateByEvent(`onChatSession:${chatViewType}`);
+        return ( this._itemsProviders.has(chatViewType));
+    }
+    notifySessionItemsChange(chatSessionType) {
+        this._onDidChangeSessionItems.fire(chatSessionType);
+    }
+    async canResolveContentProvider(chatViewType) {
+        await this._extensionService.whenInstalledExtensionsRegistered();
+        const contribution = this._contributions.get(chatViewType);
+        if (contribution && !this._isContributionAvailable(contribution)) {
+            return false;
+        }
+        if (( this._contentProviders.has(chatViewType))) {
+            return true;
+        }
+        await this._extensionService.activateByEvent(`onChatSession:${chatViewType}`);
+        return ( this._contentProviders.has(chatViewType));
+    }
+    async provideChatSessionItems(chatSessionType, token) {
+        if (!(await this.canResolveItemProvider(chatSessionType))) {
+            throw Error(`Can not find provider for ${chatSessionType}`);
+        }
+        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);
+        return {
+            dispose: () => {
+                const provider = this._itemsProviders.get(chatSessionType);
+                if (provider) {
+                    this._itemsProviders.delete(chatSessionType);
+                    this._onDidChangeItemsProviders.fire(provider);
+                }
+            }
+        };
+    }
+    registerChatSessionContentProvider(provider) {
+        this._contentProviders.set(provider.chatSessionType, provider);
+        return {
+            dispose: () => {
+                this._contentProviders.delete(provider.chatSessionType);
+                for (const [key, session] of this._sessions) {
+                    if (session.chatSessionType === provider.chatSessionType) {
+                        session.dispose();
+                        this._sessions.delete(key);
+                    }
+                }
+            }
+        };
+    }
+    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);
+        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);
+        return session;
+    }
+    _onWillDisposeSession(session, chatSessionType, id) {
+        const sessionKey = `${chatSessionType}_${id}`;
+        this._sessions.delete(sessionKey);
+    }
+    get hasChatSessionItemProviders() {
+        return this._itemsProviders.size > 0;
+    }
+};
+ChatSessionsService = ( __decorate([
+    ( __param(0, ILogService)),
+    ( __param(1, IInstantiationService)),
+    ( __param(2, IChatAgentService)),
+    ( __param(3, IExtensionService)),
+    ( __param(4, IContextKeyService))
+], ChatSessionsService));
+let CodingAgentChatImplementation = class CodingAgentChatImplementation extends Disposable {
+    constructor(chatSession, chatService, chatWidgetService, editorGroupService, chatSessionService) {
+        super();
+        this.chatSession = chatSession;
+        this.chatService = chatService;
+        this.chatWidgetService = chatWidgetService;
+        this.editorGroupService = editorGroupService;
+        this.chatSessionService = chatSessionService;
+    }
+    async invoke(request, progress, history, token) {
+        const widget = this.chatWidgetService.getWidgetBySessionId(request.sessionId);
+        if (!widget) {
+            return {};
+        }
+        let chatSession;
+        for (const group of this.editorGroupService.groups) {
+            if (chatSession) {
+                break;
+            }
+            for (const editor of group.editors) {
+                if (editor instanceof ChatEditorInput) {
+                    try {
+                        const chatModel = await this.chatService.loadSessionForResource(editor.resource, request.location, CancellationToken.None);
+                        if (chatModel?.sessionId === request.sessionId) {
+                            const identifier = ChatSessionUri.parse(editor.resource);
+                            if (identifier) {
+                                chatSession = await this.chatSessionService.provideChatSessionContent(this.chatSession.type, identifier.sessionId, token);
+                            }
+                            break;
+                        }
+                    }
+                    catch (error) {
+                    }
+                }
+            }
+        }
+        if (chatSession?.requestHandler) {
+            await chatSession.requestHandler(request, progress, [], token);
+        }
+        else {
+            const content = ( new MarkdownString(( localize(
+                5079,
+                "Use `#copilotCodingAgent` to begin a new [coding agent session]({0}).",
+                CODING_AGENT_DOCS
+            ))));
+            progress([{
+                    kind: 'markdownContent',
+                    content,
+                }]);
+        }
+        return {};
+    }
+};
+CodingAgentChatImplementation = ( __decorate([
+    ( __param(1, IChatService)),
+    ( __param(2, IChatWidgetService)),
+    ( __param(3, IEditorGroupsService)),
+    ( __param(4, IChatSessionsService))
+], CodingAgentChatImplementation));
+
+export { ChatSessionsService };

package/vscode/src/vs/workbench/contrib/chat/browser/chatSessions.d.ts

@@ -0,0 +1,12 @@
+import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IWorkbenchContribution } from "@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions";
+export declare const VIEWLET_ID = "workbench.view.chat.sessions";
+export declare class ChatSessionsView extends Disposable implements IWorkbenchContribution {
+    private readonly configurationService;
+    static readonly ID = "workbench.contrib.chatSessions";
+    private isViewContainerRegistered;
+    constructor(configurationService: IConfigurationService);
+    private updateViewContainerRegistration;
+    private registerViewContainer;
+}