@codingame/monaco-vscode-chat-service-override 20.4.1 → 21.0.0

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

@@ -33,13 +33,13 @@ import { ChatAgentLocation } from '@codingame/monaco-vscode-api/vscode/vs/workbe
 
 var QuickChat_1;
 let QuickChatService = class QuickChatService extends Disposable {
+    get onDidClose() { return this._onDidClose.event; }
     constructor(quickInputService, chatService, instantiationService) {
         super();
         this.quickInputService = quickInputService;
         this.chatService = chatService;
         this.instantiationService = instantiationService;
         this._onDidClose = this._register(( new Emitter()));
-        this.onDidClose = this._onDidClose.event;
     }
     get enabled() {
         return !!this.chatService.isEnabled(ChatAgentLocation.Panel);
@@ -181,7 +181,7 @@ let QuickChat = class QuickChat extends Disposable {
             IContextKeyService,
             this._register(this.contextKeyService.createScoped(parent))
         ]))));
-        this.widget = this._register(scopedInstantiationService.createInstance(ChatWidget, ChatAgentLocation.Panel, { isQuickChat: true }, { autoScroll: true, renderInputOnTop: true, renderStyle: 'compact', menus: { inputSideToolbar: MenuId.ChatInputSide }, enableImplicitContext: true }, {
+        this.widget = this._register(scopedInstantiationService.createInstance(ChatWidget, ChatAgentLocation.Panel, { isQuickChat: true }, { autoScroll: true, renderInputOnTop: true, renderStyle: 'compact', menus: { inputSideToolbar: MenuId.ChatInputSide, telemetrySource: 'chatQuick' }, enableImplicitContext: true }, {
             listForeground: quickInputForeground,
             listBackground: quickInputBackground,
             overlayBackground: EDITOR_DRAG_AND_DROP_BACKGROUND,

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

@@ -5,7 +5,7 @@ import { stripIcons } from '@codingame/monaco-vscode-api/vscode/vs/base/common/i
 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 { migrateLegacyTerminalToolSpecificData } from '@codingame/monaco-vscode-c2deffc4-ad68-5e63-8f95-9b89e0fc6898-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-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';

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

@@ -4,7 +4,9 @@ import { Disposable, IDisposable } from "@codingame/monaco-vscode-api/vscode/vs/
 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 { IEditableData } from "@codingame/monaco-vscode-api/vscode/vs/workbench/common/views";
 import { IExtensionService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extensions.service";
+import { IChatAgentRequest } from "@codingame/monaco-vscode-b994942c-360d-5b68-8a33-77d4bde6b714-common/vscode/vs/workbench/contrib/chat/common/chatAgents";
 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";
@@ -20,30 +22,56 @@ export declare class ChatSessionsService extends Disposable implements IChatSess
     readonly onDidChangeItemsProviders: Event<IChatSessionItemProvider>;
     private readonly _contentProviders;
     private readonly _contributions;
-    private readonly _dynamicAgentDisposables;
+    private readonly _disposableStores;
     private readonly _contextKeys;
     private readonly _onDidChangeSessionItems;
     readonly onDidChangeSessionItems: Event<string>;
     private readonly _onDidChangeAvailability;
     readonly onDidChangeAvailability: Event<void>;
+    private readonly _onDidChangeInProgress;
+    get onDidChangeInProgress(): Event<void>;
+    private readonly inProgressMap;
     constructor(_logService: ILogService, _instantiationService: IInstantiationService, _chatAgentService: IChatAgentService, _extensionService: IExtensionService, _contextKeyService: IContextKeyService);
-    registerContribution(contribution: IChatSessionsExtensionPoint): IDisposable;
+    reportInProgress(chatSessionType: string, count: number): void;
+    getInProgress(): {
+        displayName: string;
+        count: number;
+    }[];
+    private updateInProgressStatus;
+    private registerContribution;
     private _isContributionAvailable;
-    private _registerDynamicAgentIfAvailable;
-    private _disposeDynamicAgent;
+    private _registerMenuItems;
+    private _registerCommands;
     private _evaluateAvailability;
+    private _enableContribution;
     private _disposeSessionsForContribution;
     private _registerDynamicAgent;
-    getChatSessionContributions(): IChatSessionsExtensionPoint[];
-    getChatSessionItemProviders(): IChatSessionItemProvider[];
+    getAllChatSessionContributions(): IChatSessionsExtensionPoint[];
+    getAllChatSessionItemProviders(): 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;
+    registerChatSessionContentProvider(chatSessionType: string, provider: IChatSessionContentProvider): IDisposable;
     private readonly _sessions;
+    private readonly _editableSessions;
+    /**
+     * Creates a new chat session by delegating to the appropriate provider
+     * @param chatSessionType The type of chat session provider to use
+     * @param options Options for the new session including the request
+     * @param token A cancellation token
+     * @returns A session ID for the newly created session
+     */
+    provideNewChatSessionItem(chatSessionType: string, options: {
+        request: IChatAgentRequest;
+        prompt?: string;
+        history?: any[];
+        metadata?: any;
+    }, token: CancellationToken): Promise<IChatSessionItem>;
     provideChatSessionContent(chatSessionType: string, id: string, token: CancellationToken): Promise<ChatSession>;
     private _onWillDisposeSession;
-    get hasChatSessionItemProviders(): boolean;
+    setEditableSession(sessionId: string, data: IEditableData | null): Promise<void>;
+    getEditableData(sessionId: string): IEditableData | undefined;
+    isEditable(sessionId: string): boolean;
+    notifySessionItemsChanged(chatSessionType: string): void;
 }

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

@@ -3,57 +3,84 @@ import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib
 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 { DisposableStore, Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { truncate } from '@codingame/monaco-vscode-api/vscode/vs/base/common/strings';
+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 { 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 { 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 { 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 { ChatContextKeys } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatContextKeys';
 import { IChatService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService.service';
+import { ChatSessionStatus } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService';
 import { IChatSessionsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService.service';
 import { 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';
+import { CHAT_CATEGORY } from '@codingame/monaco-vscode-c2deffc4-ad68-5e63-8f95-9b89e0fc6898-common/vscode/vs/workbench/contrib/chat/browser/actions/chatActions';
+import { VIEWLET_ID } from '@codingame/monaco-vscode-c2deffc4-ad68-5e63-8f95-9b89e0fc6898-common/vscode/vs/workbench/contrib/chat/browser/chatSessions';
 
 const CODING_AGENT_DOCS = 'https://code.visualstudio.com/docs/copilot/copilot-coding-agent';
 const extensionPoint = ExtensionsRegistry.registerExtensionPoint({
     extensionPoint: 'chatSessions',
     jsonSchema: {
-        description: ( localize(5076, 'Contributes chat session integrations to the chat widget.')),
+        description: ( localize(5169, 'Contributes chat session integrations to the chat widget.')),
         type: 'array',
         items: {
             type: 'object',
             properties: {
                 type: {
-                    description: ( localize(5077, 'Unique identifier for the type of chat session.')),
+                    description: ( localize(5170, 'Unique identifier for the type of chat session.')),
                     type: 'string',
                 },
                 name: {
-                    description: ( localize(5078, 'Name shown in the chat widget. (eg: @agent)')),
+                    description: ( localize(5171, 'Name shown in the chat widget. (eg: @agent)')),
                     type: 'string',
                 },
                 displayName: {
-                    description: ( localize(5079, 'A longer name for this item which is used for display in menus.')),
+                    description: ( localize(5172, 'A longer name for this item which is used for display in menus.')),
                     type: 'string',
                 },
                 description: {
-                    description: ( localize(5080, 'Description of the chat session for use in menus and tooltips.')),
+                    description: ( localize(5173, 'Description of the chat session for use in menus and tooltips.')),
                     type: 'string'
                 },
                 when: {
-                    description: ( localize(5081, 'Condition which must be true to show this item.')),
+                    description: ( localize(5174, 'Condition which must be true to show this item.')),
                     type: 'string'
+                },
+                capabilities: {
+                    description: ( localize(5175, 'Optional capabilities for this chat session.')),
+                    type: 'object',
+                    properties: {
+                        supportsFileAttachments: {
+                            description: ( localize(
+                                5176,
+                                'Whether this chat session supports attaching files or file references.'
+                            )),
+                            type: 'boolean'
+                        },
+                        supportsToolAttachments: {
+                            description: ( localize(
+                                5177,
+                                'Whether this chat session supports attaching tools or tool references.'
+                            )),
+                            type: 'boolean'
+                        }
+                    }
                 }
             },
-            required: ['id', 'name', 'displayName', 'description'],
+            required: ['type', 'name', 'displayName', 'description'],
         }
     },
     activationEventsGenerator: (contribs, results) => {
@@ -78,6 +105,7 @@ class ContributedChatSessionData {
     }
 }
 let ChatSessionsService = class ChatSessionsService extends Disposable {
+    get onDidChangeInProgress() { return this._onDidChangeInProgress.event; }
     constructor(_logService, _instantiationService, _chatAgentService, _extensionService, _contextKeyService) {
         super();
         this._logService = _logService;
@@ -90,13 +118,16 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
         this.onDidChangeItemsProviders = this._onDidChangeItemsProviders.event;
         this._contentProviders = ( new Map());
         this._contributions = ( new Map());
-        this._dynamicAgentDisposables = ( new Map());
+        this._disposableStores = ( 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._onDidChangeInProgress = this._register(( new Emitter()));
+        this.inProgressMap = ( new Map());
         this._sessions = ( new Map());
+        this._editableSessions = ( new Map());
         this._register(extensionPoint.setHandler(extensions => {
             for (const ext of extensions) {
                 if (!isProposedApiEnabled(ext.description, 'chatSessionsProvider')) {
@@ -107,15 +138,14 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
                 }
                 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,
+                        capabilities: contribution.capabilities,
                         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));
                 }
             }
@@ -123,6 +153,37 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
         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);
+            });
+        }));
+    }
+    reportInProgress(chatSessionType, count) {
+        let displayName;
+        if (chatSessionType === 'local') {
+            displayName = 'Local Chat Sessions';
+        }
+        else {
+            displayName = this._contributions.get(chatSessionType)?.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.provideChatSessionItems(chatSessionType, CancellationToken.None);
+            const inProgress = items.filter(item => item.status === ChatSessionStatus.InProgress);
+            this.reportInProgress(chatSessionType, inProgress.length);
+        }
+        catch (error) {
+            this._logService.warn(`Failed to update in-progress status for chat session type '${chatSessionType}':`, error);
+        }
     }
     registerContribution(contribution) {
         if (( this._contributions.has(contribution.type))) {
@@ -138,11 +199,15 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
             }
         }
         this._contributions.set(contribution.type, contribution);
-        this._registerDynamicAgentIfAvailable(contribution);
+        this._evaluateAvailability();
         return {
             dispose: () => {
                 this._contributions.delete(contribution.type);
-                this._disposeDynamicAgent(contribution.type);
+                const store = this._disposableStores.get(contribution.type);
+                if (store) {
+                    store.dispose();
+                    this._disposableStores.delete(contribution.type);
+                }
             }
         };
     }
@@ -153,31 +218,66 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
         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);
-        }
+    _registerMenuItems(contribution) {
+        return MenuRegistry.appendMenuItem(MenuId.ViewTitle, {
+            command: {
+                id: `workbench.action.chat.openNewSessionEditor.${contribution.type}`,
+                title: ( localize(5178, "New {0} Chat Editor", contribution.displayName)),
+                icon: Codicon.plus,
+            },
+            group: 'navigation',
+            order: 1,
+            when: ( ContextKeyExpr.and(( ContextKeyExpr.equals('view', `${VIEWLET_ID}.${contribution.type}`)))),
+        });
     }
-    _disposeDynamicAgent(contributionId) {
-        const disposable = this._dynamicAgentDisposables.get(contributionId);
-        if (disposable) {
-            disposable.dispose();
-            this._dynamicAgentDisposables.delete(contributionId);
-        }
+    _registerCommands(contribution) {
+        return registerAction2(class OpenNewChatSessionEditorAction extends Action2 {
+            constructor() {
+                super({
+                    id: `workbench.action.chat.openNewSessionEditor.${contribution.type}`,
+                    title: ( localize2(5178, "New {0} Chat Editor", contribution.displayName)),
+                    category: CHAT_CATEGORY,
+                    icon: Codicon.plus,
+                    f1: true,
+                    precondition: ChatContextKeys.enabled
+                });
+            }
+            async run(accessor) {
+                const editorService = accessor.get(IEditorService);
+                const logService = accessor.get(ILogService);
+                const { type } = contribution;
+                try {
+                    const options = {
+                        override: ChatEditorInput.EditorID,
+                        pinned: true,
+                    };
+                    await editorService.openEditor({
+                        resource: ChatEditorInput.getNewEditorUri().with({ query: `chatSessionType=${type}` }),
+                        options,
+                    });
+                }
+                catch (e) {
+                    logService.error(`Failed to open new '${type}' chat session editor`, e);
+                }
+            }
+        });
     }
     _evaluateAvailability() {
         let hasChanges = false;
         for (const contribution of ( this._contributions.values())) {
-            const isCurrentlyRegistered = ( this._dynamicAgentDisposables.has(contribution.type));
+            const isCurrentlyRegistered = ( this._disposableStores.has(contribution.type));
             const shouldBeRegistered = this._isContributionAvailable(contribution);
             if (isCurrentlyRegistered && !shouldBeRegistered) {
-                this._disposeDynamicAgent(contribution.type);
+                const store = this._disposableStores.get(contribution.type);
+                if (store) {
+                    store.dispose();
+                    this._disposableStores.delete(contribution.type);
+                }
                 this._disposeSessionsForContribution(contribution.type);
                 hasChanges = true;
             }
             else if (!isCurrentlyRegistered && shouldBeRegistered) {
-                this._registerDynamicAgentIfAvailable(contribution);
+                this._enableContribution(contribution);
                 hasChanges = true;
             }
         }
@@ -191,6 +291,13 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
             }
         }
     }
+    _enableContribution(contribution) {
+        const disposableStore = ( new DisposableStore());
+        this._disposableStores.set(contribution.type, disposableStore);
+        disposableStore.add(this._registerDynamicAgent(contribution));
+        disposableStore.add(this._registerCommands(contribution));
+        disposableStore.add(this._registerMenuItems(contribution));
+    }
     _disposeSessionsForContribution(contributionId) {
         const sessionsToDispose = [];
         for (const [sessionKey, sessionData] of this._sessions) {
@@ -219,7 +326,6 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
             isDefault: false,
             isCore: false,
             isDynamic: true,
-            isCodingAgent: true,
             slashCommands: [],
             locations: [ChatAgentLocation.Panel],
             modes: [ChatModeKind.Agent, ChatModeKind.Ask],
@@ -228,7 +334,9 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
                 themeIcon: Codicon.sendToRemoteAgent,
                 isSticky: false,
             },
+            capabilities: contribution.capabilities,
             extensionId,
+            extensionVersion: extensionDescription.version,
             extensionDisplayName: extensionDisplayName || extensionName,
             extensionPublisherId,
         };
@@ -236,10 +344,10 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
         const disposable = this._chatAgentService.registerDynamicAgent(agentData, agentImpl);
         return disposable;
     }
-    getChatSessionContributions() {
+    getAllChatSessionContributions() {
         return Array.from(( this._contributions.values())).filter(contribution => this._isContributionAvailable(contribution));
     }
-    getChatSessionItemProviders() {
+    getAllChatSessionItemProviders() {
         return [...( this._itemsProviders.values())].filter(provider => {
             const contribution = this._contributions.get(provider.chatSessionType);
             return !contribution || this._isContributionAvailable(contribution);
@@ -257,9 +365,6 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
         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);
@@ -287,8 +392,16 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
         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);
@@ -297,13 +410,13 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
             }
         };
     }
-    registerChatSessionContentProvider(provider) {
-        this._contentProviders.set(provider.chatSessionType, provider);
+    registerChatSessionContentProvider(chatSessionType, provider) {
+        this._contentProviders.set(chatSessionType, provider);
         return {
             dispose: () => {
-                this._contentProviders.delete(provider.chatSessionType);
+                this._contentProviders.delete(chatSessionType);
                 for (const [key, session] of this._sessions) {
-                    if (session.chatSessionType === provider.chatSessionType) {
+                    if (session.chatSessionType === chatSessionType) {
                         session.dispose();
                         this._sessions.delete(key);
                     }
@@ -311,6 +424,18 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
             }
         };
     }
+    async provideNewChatSessionItem(chatSessionType, options, token) {
+        if (!(await this.canResolveItemProvider(chatSessionType))) {
+            throw Error(`Cannot find provider for ${chatSessionType}`);
+        }
+        const provider = this._itemsProviders.get(chatSessionType);
+        if (!provider?.provideNewChatSessionItem) {
+            throw Error(`Provider for ${chatSessionType} does not support creating sessions`);
+        }
+        const chatSessionItem = await provider.provideNewChatSessionItem(options, token);
+        this._onDidChangeSessionItems.fire(chatSessionType);
+        return chatSessionItem;
+    }
     async provideChatSessionContent(chatSessionType, id, token) {
         if (!(await this.canResolveContentProvider(chatSessionType))) {
             throw Error(`Can not find provider for ${chatSessionType}`);
@@ -333,8 +458,23 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
         const sessionKey = `${chatSessionType}_${id}`;
         this._sessions.delete(sessionKey);
     }
-    get hasChatSessionItemProviders() {
-        return this._itemsProviders.size > 0;
+    async setEditableSession(sessionId, data) {
+        if (!data) {
+            this._editableSessions.delete(sessionId);
+        }
+        else {
+            this._editableSessions.set(sessionId, data);
+        }
+        this._onDidChangeSessionItems.fire('local');
+    }
+    getEditableData(sessionId) {
+        return this._editableSessions.get(sessionId);
+    }
+    isEditable(sessionId) {
+        return ( this._editableSessions.has(sessionId));
+    }
+    notifySessionItemsChanged(chatSessionType) {
+        this._onDidChangeSessionItems.fire(chatSessionType);
     }
 };
 ChatSessionsService = ( __decorate([
@@ -345,13 +485,15 @@ ChatSessionsService = ( __decorate([
     ( __param(4, IContextKeyService))
 ], ChatSessionsService));
 let CodingAgentChatImplementation = class CodingAgentChatImplementation extends Disposable {
-    constructor(chatSession, chatService, chatWidgetService, editorGroupService, chatSessionService) {
+    constructor(chatSession, chatService, chatWidgetService, editorGroupService, chatSessionService, editorService, logService) {
         super();
         this.chatSession = chatSession;
         this.chatService = chatService;
         this.chatWidgetService = chatWidgetService;
         this.editorGroupService = editorGroupService;
         this.chatSessionService = chatSessionService;
+        this.editorService = editorService;
+        this.logService = logService;
     }
     async invoke(request, progress, history, token) {
         const widget = this.chatWidgetService.getWidgetBySessionId(request.sessionId);
@@ -381,18 +523,60 @@ let CodingAgentChatImplementation = class CodingAgentChatImplementation extends
             }
         }
         if (chatSession?.requestHandler) {
-            await chatSession.requestHandler(request, progress, [], token);
+            await chatSession.requestHandler(request, progress, history, token);
         }
         else {
-            const content = ( new MarkdownString(( localize(
-                5082,
-                "Use `#copilotCodingAgent` to begin a new [coding agent session]({0}).",
-                CODING_AGENT_DOCS
-            ))));
-            progress([{
-                    kind: 'markdownContent',
-                    content,
-                }]);
+            try {
+                const chatSessionItem = await this.chatSessionService.provideNewChatSessionItem(this.chatSession.type, {
+                    request,
+                    prompt: request.message,
+                    history,
+                }, token);
+                const options = {
+                    pinned: true,
+                    preferredTitle: truncate(chatSessionItem.label, 30),
+                };
+                await this.chatSessionService.provideChatSessionContent(this.chatSession.type, chatSessionItem.id, token);
+                const activeGroup = this.editorGroupService.activeGroup;
+                const currentEditor = activeGroup?.activeEditor;
+                if (currentEditor instanceof ChatEditorInput) {
+                    await this.editorService.replaceEditors([{
+                            editor: currentEditor,
+                            replacement: {
+                                resource: ChatSessionUri.forSession(this.chatSession.type, chatSessionItem.id),
+                                options,
+                            }
+                        }], activeGroup);
+                }
+                else {
+                    await this.editorService.openEditor({
+                        resource: ChatSessionUri.forSession(this.chatSession.type, chatSessionItem.id),
+                        options,
+                    });
+                    progress([{
+                            kind: 'markdownContent',
+                            content: ( new MarkdownString(( localize(
+                                5179,
+                                'Continue **{0}** in a new chat editor',
+                                truncate(chatSessionItem.label, 30)
+                            )))),
+                        }]);
+                }
+            }
+            catch (error) {
+                this.logService.error(`Failed to create new chat session for type '${this.chatSession.type}'`, error);
+                const content = this.chatSession.type === 'copilot-swe-agent'
+                    ? ( new MarkdownString(( localize(
+                    5180,
+                    "Failed to create chat session. Use `#copilotCodingAgent` to begin a new [coding agent session]({0}).",
+                    CODING_AGENT_DOCS
+                ))))
+                    : ( new MarkdownString(( localize(5181, "Failed to create chat session. Please try again later."))));
+                progress([{
+                        kind: 'markdownContent',
+                        content,
+                    }]);
+            }
         }
         return {};
     }
@@ -401,7 +585,9 @@ CodingAgentChatImplementation = ( __decorate([
     ( __param(1, IChatService)),
     ( __param(2, IChatWidgetService)),
     ( __param(3, IEditorGroupsService)),
-    ( __param(4, IChatSessionsService))
+    ( __param(4, IChatSessionsService)),
+    ( __param(5, IEditorService)),
+    ( __param(6, ILogService))
 ], CodingAgentChatImplementation));
 
 export { ChatSessionsService };