@codingame/monaco-vscode-api 34.1.3 → 35.0.0

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

@@ -8,7 +8,7 @@ import { Emitter, Event } from '../../../../../base/common/event.js';
 import { Disposable, DisposableMap, DisposableStore, combinedDisposable, toDisposable } from '../../../../../base/common/lifecycle.js';
 import { ResourceMap, ResourceSet } from '../../../../../base/common/map.js';
 import { Schemas } from '../../../../../base/common/network.js';
-import { joinPath } from '../../../../../base/common/resources.js';
+import { joinPath, isEqual } from '../../../../../base/common/resources.js';
 import { ThemeIcon } from '../../../../../base/common/themables.js';
 import { URI } from '../../../../../base/common/uri.js';
 import { localize, localize2 } from '../../../../../nls.js';
@@ -17,8 +17,10 @@ import { IMenuService } from '../../../../../platform/actions/common/actions.ser
 import { ContextKeyExpr } from '../../../../../platform/contextkey/common/contextkey.js';
 import { IContextKeyService } from '../../../../../platform/contextkey/common/contextkey.service.js';
 import '../../../../../platform/instantiation/common/extensions.js';
+import { IInstantiationService } from '../../../../../platform/instantiation/common/instantiation.js';
 import { ILabelService } from '../../../../../platform/label/common/label.service.js';
 import { ILogService } from '../../../../../platform/log/common/log.service.js';
+import { Registry } from '../../../../../platform/registry/common/platform.js';
 import { isDark } from '../../../../../platform/theme/common/theme.js';
 import { IThemeService } from '../../../../../platform/theme/common/themeService.service.js';
 import { IEditorService } from '../../../../services/editor/common/editorService.service.js';
@@ -28,7 +30,7 @@ import { ExtensionsRegistry } from '../../../../services/extensions/common/exten
 import { ChatEditorInput } from '../widgetHosts/editor/chatEditorInput.js';
 import { IChatAgentService } from '../../common/participants/chatAgents.service.js';
 import { ChatContextKeys } from '../../common/actions/chatContextKeys.js';
-import { isSessionInProgressStatus, ChatSessionOptionsMap, ChatSessionStatus } from '../../common/chatSessionsService.js';
+import { ChatSessionsExtensions, isSessionInProgressStatus, localChatSessionType, ChatSessionOptionsMap, ChatSessionStatus } from '../../common/chatSessionsService.js';
 import { IChatSessionsService } from '../../common/chatSessionsService.service.js';
 import { ChatAgentLocation, ChatModeKind } from '../../common/constants.js';
 import { CHAT_CATEGORY } from '../actions/chatActions.js';
@@ -56,39 +58,39 @@ import { autorun } from '../../../../../base/common/observableInternal/reactions
 const extensionPoint = ExtensionsRegistry.registerExtensionPoint({
     extensionPoint: "chatSessions",
     jsonSchema: {
-        description: ( localize(6677, "Contributes chat session integrations to the chat widget.")),
+        description: ( localize(7180, "Contributes chat session integrations to the chat widget.")),
         type: "array",
         items: {
             type: "object",
             additionalProperties: false,
             properties: {
                 type: {
-                    description: ( localize(6678, "Unique identifier for the type of chat session.")),
+                    description: ( localize(7181, "Unique identifier for the type of chat session.")),
                     type: "string"
                 },
                 name: {
                     description: ( localize(
-                        6679,
+                        7182,
                         "Name of the dynamically registered chat participant (eg: @agent). Must not contain whitespace."
                     )),
                     type: "string",
                     pattern: "^[\\w-]+$"
                 },
                 displayName: {
-                    description: ( localize(6680, "A longer name for this item which is used for display in menus.")),
+                    description: ( localize(7183, "A longer name for this item which is used for display in menus.")),
                     type: "string"
                 },
                 description: {
-                    description: ( localize(6681, "Description of the chat session for use in menus and tooltips.")),
+                    description: ( localize(7184, "Description of the chat session for use in menus and tooltips.")),
                     type: "string"
                 },
                 when: {
-                    description: ( localize(6682, "Condition which must be true to show this item.")),
+                    description: ( localize(7185, "Condition which must be true to show this item.")),
                     type: "string"
                 },
                 icon: {
                     description: ( localize(
-                        6683,
+                        7186,
                         "Icon identifier (codicon ID) for the chat session editor tab. For example, \"{0}\" or \"{1}\".",
                         "$(github)",
                         "$(cloud)"
@@ -99,22 +101,22 @@ const extensionPoint = ExtensionsRegistry.registerExtensionPoint({
                         type: "object",
                         properties: {
                             light: {
-                                description: ( localize(6684, "Icon path when a light theme is used")),
+                                description: ( localize(7187, "Icon path when a light theme is used")),
                                 type: "string"
                             },
                             dark: {
-                                description: ( localize(6685, "Icon path when a dark theme is used")),
+                                description: ( localize(7188, "Icon path when a dark theme is used")),
                                 type: "string"
                             }
                         }
                     }]
                 },
                 order: {
-                    description: ( localize(6686, "Order in which this item should be displayed.")),
+                    description: ( localize(7189, "Order in which this item should be displayed.")),
                     type: "integer"
                 },
                 alternativeIds: {
-                    description: ( localize(6687, "Alternative identifiers for backward compatibility.")),
+                    description: ( localize(7190, "Alternative identifiers for backward compatibility.")),
                     type: "array",
                     items: {
                         type: "string"
@@ -122,95 +124,95 @@ const extensionPoint = ExtensionsRegistry.registerExtensionPoint({
                 },
                 welcomeTitle: {
                     description: ( localize(
-                        6688,
+                        7191,
                         "Title text to display in the chat welcome view for this session type."
                     )),
                     type: "string"
                 },
                 welcomeMessage: {
                     description: ( localize(
-                        6689,
+                        7192,
                         "Message text (supports markdown) to display in the chat welcome view for this session type."
                     )),
                     type: "string"
                 },
                 welcomeTips: {
                     description: ( localize(
-                        6690,
+                        7193,
                         "Tips text (supports markdown and theme icons) to display in the chat welcome view for this session type."
                     )),
                     type: "string"
                 },
                 inputPlaceholder: {
                     description: ( localize(
-                        6691,
+                        7194,
                         "Placeholder text to display in the chat input box for this session type."
                     )),
                     type: "string"
                 },
                 capabilities: {
-                    description: ( localize(6692, "Optional capabilities for this chat session.")),
+                    description: ( localize(7195, "Optional capabilities for this chat session.")),
                     type: "object",
                     additionalProperties: false,
                     properties: {
                         supportsFileAttachments: {
                             description: ( localize(
-                                6693,
+                                7196,
                                 "Whether this chat session supports attaching files or file references."
                             )),
                             type: "boolean"
                         },
                         supportsToolAttachments: {
                             description: ( localize(
-                                6694,
+                                7197,
                                 "Whether this chat session supports attaching tools or tool references."
                             )),
                             type: "boolean"
                         },
                         supportsMCPAttachments: {
-                            description: ( localize(6695, "Whether this chat session supports attaching MCP resources.")),
+                            description: ( localize(7198, "Whether this chat session supports attaching MCP resources.")),
                             type: "boolean"
                         },
                         supportsImageAttachments: {
-                            description: ( localize(6696, "Whether this chat session supports attaching images.")),
+                            description: ( localize(7199, "Whether this chat session supports attaching images.")),
                             type: "boolean"
                         },
                         supportsSearchResultAttachments: {
-                            description: ( localize(6697, "Whether this chat session supports attaching search results.")),
+                            description: ( localize(7200, "Whether this chat session supports attaching search results.")),
                             type: "boolean"
                         },
                         supportsInstructionAttachments: {
-                            description: ( localize(6698, "Whether this chat session supports attaching instructions.")),
+                            description: ( localize(7201, "Whether this chat session supports attaching instructions.")),
                             type: "boolean"
                         },
                         supportsSourceControlAttachments: {
                             description: ( localize(
-                                6699,
+                                7202,
                                 "Whether this chat session supports attaching source control changes."
                             )),
                             type: "boolean"
                         },
                         supportsProblemAttachments: {
-                            description: ( localize(6700, "Whether this chat session supports attaching problems.")),
+                            description: ( localize(7203, "Whether this chat session supports attaching problems.")),
                             type: "boolean"
                         },
                         supportsSymbolAttachments: {
-                            description: ( localize(6701, "Whether this chat session supports attaching symbols.")),
+                            description: ( localize(7204, "Whether this chat session supports attaching symbols.")),
                             type: "boolean"
                         },
                         supportsPromptAttachments: {
-                            description: ( localize(6702, "Whether this chat session supports attaching prompts.")),
+                            description: ( localize(7205, "Whether this chat session supports attaching prompts.")),
                             type: "boolean"
                         },
                         supportsHandOffs: {
-                            description: ( localize(6703, "Whether this chat session supports hand-off prompts.")),
+                            description: ( localize(7206, "Whether this chat session supports hand-off prompts.")),
                             type: "boolean"
                         }
                     }
                 },
                 commands: {
                     markdownDescription: ( localize(
-                        6704,
+                        7207,
                         "Commands available for this chat session, which the user can invoke with a `/`."
                     )),
                     type: "array",
@@ -227,17 +229,17 @@ const extensionPoint = ExtensionsRegistry.registerExtensionPoint({
                         properties: {
                             name: {
                                 description: ( localize(
-                                    6705,
+                                    7208,
                                     "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(6706, "A description of this command.")),
+                                description: ( localize(7209, "A description of this command.")),
                                 type: "string"
                             },
                             when: {
-                                description: ( localize(6707, "A condition which must be true to enable this command.")),
+                                description: ( localize(7210, "A condition which must be true to enable this command.")),
                                 type: "string"
                             }
                         }
@@ -245,7 +247,7 @@ const extensionPoint = ExtensionsRegistry.registerExtensionPoint({
                 },
                 canDelegate: {
                     description: ( localize(
-                        6708,
+                        7211,
                         "Whether delegation is supported. Default is false. Note that enabling this is experimental and may not be respected at all times."
                     )),
                     type: "boolean",
@@ -253,22 +255,38 @@ const extensionPoint = ExtensionsRegistry.registerExtensionPoint({
                 },
                 customAgentTarget: {
                     description: ( localize(
-                        6709,
+                        7212,
                         "When set, the chat session will show a filtered mode picker that prefers custom agents whose target property matches this value. Custom agents without a target property are still shown in all session types. This enables the use of standard agent/mode with contributed sessions."
                     )),
                     type: "string"
                 },
                 requiresCustomModels: {
                     description: ( localize(
-                        6710,
+                        7213,
                         "When set, the chat session will show a filtered model picker that prefers custom models. This enables the use of standard model picker with contributed sessions."
                     )),
                     type: "boolean",
                     default: false
                 },
+                supportsAutoModel: {
+                    description: ( localize(
+                        7214,
+                        "Whether the chat session supports the synthetic \"Auto\" model fallback. Defaults to false. When true and no models are available, the picker shows \"Auto\" instead of a \"No models available\" state."
+                    )),
+                    type: "boolean",
+                    default: false
+                },
+                requiresCopilotSignIn: {
+                    description: ( localize(
+                        7215,
+                        "Whether the chat session relies on a GitHub Copilot account and so cannot be used until the user signs in. Defaults to false."
+                    )),
+                    type: "boolean",
+                    default: false
+                },
                 autoAttachReferences: {
                     description: ( localize(
-                        6711,
+                        7216,
                         "Whether to automatically attach instruction files to chat requests for this session type."
                     )),
                     type: "boolean",
@@ -276,7 +294,7 @@ const extensionPoint = ExtensionsRegistry.registerExtensionPoint({
                 },
                 useRequestToPopulateBuiltInPickers: {
                     description: ( localize(
-                        6712,
+                        7217,
                         "Whether to use ChatRequestTurn2 to populate built-in pickers such as the Agent and Model pickers."
                     )),
                     type: "boolean",
@@ -335,7 +353,8 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
         _contextKeyService,
         _menuService,
         _themeService,
-        _labelService
+        _labelService,
+        _instantiationService
     ) {
         super();
         this._logService = _logService;
@@ -345,7 +364,9 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
         this._menuService = _menuService;
         this._themeService = _themeService;
         this._labelService = _labelService;
+        this._instantiationService = _instantiationService;
         this._itemControllers = ( new Map());
+        this._asyncActivationRegistry = ( Registry.as(ChatSessionsExtensions.AsyncActivation));
         this._contributions = ( new Map());
         this._contributionDisposables = this._register(( new DisposableMap()));
         this._contentProviders = ( new Map());
@@ -367,6 +388,7 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
         this._sessionTypeOptions = ( new Map());
         this._sessions = ( new ResourceMap());
         this._resourceAliases = ( new ResourceMap());
+        this._realResources = ( new ResourceMap());
         this._customizationsProviders = ( new Map());
         this._onDidChangeCustomizations = this._register(( new Emitter()));
         this.onDidChangeCustomizations = this._onDidChangeCustomizations.event;
@@ -402,9 +424,8 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
             for (const type of activatedProviders) {
                 const knownProvider = getAgentSessionProvider(type);
                 if (knownProvider) {
-                    reader.store.add(
-                        registerNewSessionInPlaceAction(type, getAgentSessionProviderName(knownProvider))
-                    );
+                    const label = getAgentSessionProviderName(knownProvider);
+                    reader.store.add(registerNewSessionInPlaceAction(type, label));
                 } else {
                     const contrib = this._contributions.get(type);
                     if (contrib) {
@@ -453,7 +474,9 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
             for await (const result of this.getChatSessionItems([chatSessionType], CancellationToken.None)) {
                 items.push(...result.items);
             }
-            const inProgress = items.filter(item => item.status && isSessionInProgressStatus(item.status));
+            const inProgress = items.filter(
+                item => !item.archived && item.status && isSessionInProgressStatus(item.status)
+            );
             this.reportInProgress(chatSessionType, inProgress.length);
         } catch (error) {
             this._logService.warn(
@@ -517,6 +540,11 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
         const whenExpr = ContextKeyExpr.deserialize(contribution.when);
         return !whenExpr || this._contextKeyService.contextMatchesRules(whenExpr);
     }
+    _isContributionAvailableForType(sessionType) {
+        const primaryType = ( this._contributions.has(sessionType)) ? sessionType : this._alternativeIdMap.get(sessionType);
+        const contribution = primaryType ? this._contributions.get(primaryType)?.contribution : undefined;
+        return !contribution || this._isContributionAvailable(contribution);
+    }
     _resolveToPrimaryType(sessionType) {
         const contribution = this._contributions.get(sessionType)?.contribution;
         if (contribution) {
@@ -534,36 +562,47 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
         return undefined;
     }
     _registerMenuItems(contribution, extensionDescription) {
+        const disposables = ( new DisposableStore());
+        if (!contribution.canDelegate) {
+            disposables.add(registerNewSessionExternalAction(
+                contribution.type,
+                contribution.displayName,
+                () => this._resolveCreateSubMenuCommandId(contribution.type)
+            ));
+        }
         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 (let i = 0; i < menuActions.length; i++) {
-            const action = menuActions[i];
-            if (action instanceof MenuItemAction) {
-                if (i === 0 && !contribution.canDelegate) {
-                    disposables.add(
-                        registerNewSessionExternalAction(contribution.type, contribution.displayName, action.item.id)
-                    );
-                } else {
-                    disposables.add(MenuRegistry.appendMenuItem(MenuId.ChatNewMenu, {
-                        command: action.item,
-                        group: "4_externally_contributed"
-                    }));
-                }
-            }
+        const menuItemActions = menuActions.filter(action => action instanceof MenuItemAction);
+        const actionsToMirror = contribution.canDelegate ? menuItemActions : menuItemActions.slice(1);
+        for (const action of actionsToMirror) {
+            disposables.add(MenuRegistry.appendMenuItem(MenuId.ChatNewMenu, {
+                command: action.item,
+                group: "4_externally_contributed"
+            }));
         }
         return {
             dispose: () => disposables.dispose()
         };
     }
+    _resolveCreateSubMenuCommandId(type) {
+        const contextKeyService = this._contextKeyService.createOverlay([["chatSessionType", type]]);
+        const rawMenuActions = this._menuService.getMenuActions(MenuId.AgentSessionsCreateSubMenu, contextKeyService);
+        const menuActions = ( rawMenuActions.map(value => value[1])).flat();
+        for (const action of menuActions) {
+            if (action instanceof MenuItemAction) {
+                return action.item.id;
+            }
+        }
+        return undefined;
+    }
     _registerCommands(contribution) {
         const isAvailableInSessionTypePicker = isAgentSessionProviderType(contribution.type);
         return combinedDisposable(registerAction2(class OpenChatSessionAction extends Action2 {
             constructor() {
                 super({
                     id: `workbench.action.chat.openSessionWithPrompt.${contribution.type}`,
-                    title: ( localize2(6713, "New {0} with Prompt", contribution.displayName)),
+                    title: ( localize2(7218, "New {0} with Prompt", contribution.displayName)),
                     category: CHAT_CATEGORY,
                     icon: Codicon.plus,
                     f1: false,
@@ -615,7 +654,7 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
             constructor() {
                 super({
                     id: `workbench.action.chat.openNewSessionEditor.${contribution.type}`,
-                    title: ( localize2(6714, "New {0} Session", contribution.displayName)),
+                    title: ( localize2(7219, "New {0} Session", contribution.displayName)),
                     category: CHAT_CATEGORY,
                     icon: Codicon.plus,
                     f1: true,
@@ -638,7 +677,7 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
             constructor() {
                 super({
                     id: `workbench.action.chat.openNewSessionSidebar.${contribution.type}`,
-                    title: ( localize2(6715, "New {0} Session", contribution.displayName)),
+                    title: ( localize2(7220, "New {0} Session", contribution.displayName)),
                     category: CHAT_CATEGORY,
                     icon: Codicon.plus,
                     f1: false,
@@ -854,8 +893,7 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
         if (resolvedType) {
             chatViewType = resolvedType;
         }
-        const contribution = this._contributions.get(chatViewType)?.contribution;
-        if (contribution && !this._isContributionAvailable(contribution)) {
+        if (!this._isContributionAvailableForType(chatViewType)) {
             return false;
         }
         if (( this._itemControllers.has(chatViewType))) {
@@ -867,17 +905,35 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
     }
     async canResolveChatSession(sessionType) {
         await this._extensionService.whenInstalledExtensionsRegistered();
-        const resolvedType = this._resolveToPrimaryType(sessionType) || sessionType;
-        const contribution = this._contributions.get(resolvedType)?.contribution;
-        if (contribution && !this._isContributionAvailable(contribution)) {
+        if (!this._isContributionAvailableForType(sessionType)) {
             return false;
         }
         if (( this._contentProviders.has(sessionType))) {
             return true;
         }
+        const asyncActivators = this._asyncActivationRegistry.getActivators(sessionType);
+        if (asyncActivators.length) {
+            for (const activator of asyncActivators) {
+                if (await this._instantiationService.invokeFunction(accessor => activator.waitForActivation(accessor, sessionType))) {
+                    await this.waitForContentProvider(sessionType);
+                    if (( this._contentProviders.has(sessionType))) {
+                        return true;
+                    }
+                }
+            }
+            return false;
+        }
         await this._extensionService.activateByEvent(`onChatSession:${sessionType}`);
         return ( this._contentProviders.has(sessionType));
     }
+    async waitForContentProvider(sessionType) {
+        if (( this._contentProviders.has(sessionType))) {
+            return;
+        }
+        await Event.toPromise(
+            Event.filter(this.onDidChangeContentProviderSchemes, e => e.added.includes(sessionType))
+        );
+    }
     async provideChatInputCompletions(sessionResource, params, token) {
         const sessionType = getChatSessionType(sessionResource);
         const resolvedType = this._resolveToPrimaryType(sessionType) || sessionType;
@@ -887,6 +943,11 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
         }
         return provider.provideChatInputCompletions(sessionResource, params, token);
     }
+    resolveChatResponseUri(sessionResource, href, kind) {
+        const sessionType = getChatSessionType(sessionResource);
+        const resolvedType = this._resolveToPrimaryType(sessionType) || sessionType;
+        return this._contentProviders.get(resolvedType)?.resolveChatResponseUri?.(sessionResource, href, kind) ?? href;
+    }
     async getChatInputCompletionTriggerCharacters(sessionType) {
         const resolvedType = this._resolveToPrimaryType(sessionType) || sessionType;
         const provider = this._contentProviders.get(resolvedType);
@@ -921,6 +982,9 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
                     if (providersToResolve && !providersToResolve.includes(resolvedType)) {
                         return;
                     }
+                    if (!this._isContributionAvailableForType(chatSessionType)) {
+                        return;
+                    }
                     try {
                         await raceCancellationError(controllerEntry.initialRefresh, token);
                         const providerSessions = controllerEntry.controller.items;
@@ -1051,6 +1115,16 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
         await controllerData.initialRefresh;
         return controllerData.controller.newChatSessionItem?.(request, token);
     }
+    async deleteChatSessionItem(sessionResource, token) {
+        const sessionType = getChatSessionType(sessionResource);
+        const resolvedType = this._resolveToPrimaryType(sessionType) ?? sessionType;
+        const controllerData = this._itemControllers.get(resolvedType);
+        if (!controllerData?.controller.deleteChatSessionItem) {
+            throw ( new Error(`Session ${( sessionResource.toString())} does not support deletion`));
+        }
+        await controllerData.initialRefresh;
+        return controllerData.controller.deleteChatSessionItem(sessionResource, token);
+    }
     async getOrCreateChatSession(sessionResource, token) {
         {
             const existingSessionData = this._sessions.get(sessionResource);
@@ -1060,7 +1134,7 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
         }
         const sessionType = getChatSessionType(sessionResource);
         if (!(await raceCancellationError(this.canResolveChatSession(sessionType), token))) {
-            throw Error(`Can not find provider for ${sessionResource}`);
+            throw Error(`Cannot find provider '${sessionType}'`);
         }
         {
             const existingSessionData = this._sessions.get(sessionResource);
@@ -1071,7 +1145,7 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
         const resolvedType = this._resolveToPrimaryType(sessionType) || sessionType;
         const provider = this._contentProviders.get(resolvedType);
         if (!provider) {
-            throw Error(`Can not find provider for ${sessionResource}`);
+            throw Error(`Cannot find provider '${resolvedType}'`);
         }
         let session;
         const newSessionOptionGroups = isUntitledChatSession(sessionResource) ? await this.getNewChatSessionInputState(resolvedType, sessionResource) : undefined;
@@ -1166,6 +1240,19 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
     registerSessionResourceAlias(untitledResource, realResource) {
         this._resourceAliases.set(realResource, untitledResource);
     }
+    setMaterializedSessionResource(untitledResource, realResource) {
+        this._realResources.set(untitledResource, realResource);
+    }
+    getMaterializedSessionResource(untitledResource) {
+        return this._realResources.get(untitledResource);
+    }
+    clearMaterializedSessionResource(sessionResource) {
+        this._realResources.delete(sessionResource);
+        const untitled = this._resourceAliases.get(sessionResource);
+        if (untitled) {
+            this._realResources.delete(untitled);
+        }
+    }
     fireSessionCommitted(original, committed) {
         this._onDidCommitSession.fire({
             original,
@@ -1211,10 +1298,21 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
         const contribution = this._contributions.get(chatSessionType)?.contribution;
         return !!contribution?.requiresCustomModels;
     }
+    supportsAutoModelForSessionType(chatSessionType) {
+        if (chatSessionType === localChatSessionType) {
+            return true;
+        }
+        const contribution = this._contributions.get(chatSessionType)?.contribution;
+        return !!contribution?.supportsAutoModel;
+    }
     supportsDelegationForSessionType(chatSessionType) {
         const contribution = this._contributions.get(chatSessionType)?.contribution;
         return contribution?.supportsDelegation !== false;
     }
+    requiresCopilotSignInForSessionType(chatSessionType) {
+        const contribution = this._contributions.get(chatSessionType)?.contribution;
+        return !!contribution?.requiresCopilotSignIn;
+    }
     sessionSupportsFork(sessionResource) {
         const session =
         this._sessions.get(sessionResource) ?? this._sessions.get(this._resolveResource(sessionResource));
@@ -1244,13 +1342,13 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
         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));
+ChatSessionsService = ( __decorate([( __param(0, ILogService)), ( __param(1, IChatAgentService)), ( __param(2, IExtensionService)), ( __param(3, IContextKeyService)), ( __param(4, IMenuService)), ( __param(5, IThemeService)), ( __param(6, ILabelService)), ( __param(7, IInstantiationService))], ChatSessionsService));
 function registerNewSessionInPlaceAction(type, displayName) {
     return registerAction2(class NewChatSessionInPlaceAction extends Action2 {
         constructor() {
             super({
                 id: `workbench.action.chat.openNewChatSessionInPlace.${type}`,
-                title: ( localize2(6716, "New {0} Session", displayName)),
+                title: ( localize2(7221, "New {0} Session", displayName)),
                 category: CHAT_CATEGORY,
                 f1: false,
                 precondition: ChatContextKeys.enabled
@@ -1266,19 +1364,19 @@ function registerNewSessionInPlaceAction(type, displayName) {
             }
             await openChatSession(accessor, {
                 type: type,
-                displayName: ( localize(6717, "Chat")),
+                displayName: ( localize(7222, "Chat")),
                 position: chatSessionPosition,
                 replaceEditor: true
             });
         }
     });
 }
-function registerNewSessionExternalAction(type, displayName, commandId) {
+function registerNewSessionExternalAction(type, displayName, resolveCommandId) {
     return registerAction2(class NewChatSessionExternalAction extends Action2 {
         constructor() {
             super({
                 id: `workbench.action.chat.openNewChatSessionExternal.${type}`,
-                title: ( localize2(6718, "New {0} Session", displayName)),
+                title: ( localize2(7223, "New {0} Session", displayName)),
                 category: CHAT_CATEGORY,
                 f1: false,
                 precondition: ChatContextKeys.enabled
@@ -1286,6 +1384,14 @@ function registerNewSessionExternalAction(type, displayName, commandId) {
         }
         async run(accessor) {
             const commandService = accessor.get(ICommandService);
+            const logService = accessor.get(ILogService);
+            const commandId = resolveCommandId();
+            if (!commandId) {
+                logService.warn(
+                    `[ChatSessionsService] No create command contributed to '${MenuId.AgentSessionsCreateSubMenu.id}' for chat session type '${type}'; cannot open a new session.`
+                );
+                return;
+            }
             await commandService.executeCommand(commandId);
         }
     });
@@ -1323,8 +1429,11 @@ async function openChatSession(accessor, openOptions, chatSendOptions) {
                 const options = {
                     override: ChatEditorInput.EditorID,
                     pinned: true,
+                    ...(openOptions.type === AgentSessionProviders.Local ? {
+                        explicitSessionType: localChatSessionType
+                    } : {}),
                     title: {
-                        fallback: ( localize(6719, "{0}", openOptions.displayName))
+                        fallback: ( localize(7224, "{0}", openOptions.displayName))
                     }
                 };
                 if (openOptions.replaceEditor) {
@@ -1378,10 +1487,42 @@ async function openChatSession(accessor, openOptions, chatSendOptions) {
             if (promptFile) {
                 attachedContext = [promptFile, ...(attachedContext ?? [])];
             }
-            await chatService.sendRequest(sessionResource, chatSendOptions.prompt, {
+            const result = await chatService.sendRequest(sessionResource, chatSendOptions.prompt, {
                 agentIdSilent: openOptions.type,
                 attachedContext
             });
+            if (result.kind === "sent" && result.newSessionResource && !isEqual(result.newSessionResource, sessionResource)) {
+                switch (openOptions.position) {
+                case ChatSessionPosition.Sidebar:
+                    {
+                        const view = await viewsService.openView(ChatViewId);
+                        await view.loadSession(result.newSessionResource);
+                        break;
+                    }
+                case ChatSessionPosition.Editor:
+                    {
+                        const activeEditor = editorGroupService.activeGroup.activeEditor;
+                        if (activeEditor instanceof ChatEditorInput && isEqual(activeEditor.sessionResource, sessionResource)) {
+                            await editorService.replaceEditors([{
+                                editor: activeEditor,
+                                replacement: {
+                                    resource: result.newSessionResource,
+                                    options: {
+                                        override: ChatEditorInput.EditorID,
+                                        pinned: true
+                                    }
+                                }
+                            }], editorGroupService.activeGroup);
+                        }
+                        break;
+                    }
+                default:
+                    assertNever(
+                        openOptions.position,
+                        `Unknown chat session position: ${openOptions.position}`
+                    );
+                }
+            }
         } catch (e) {
             logService.error(
                 `Failed to send initial request to '${openOptions.type}' chat session with contextOptions: ${JSON.stringify(chatSendOptions)}`,