@codingame/monaco-vscode-katex-common 26.2.2 → 28.0.0

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

@@ -2,7 +2,7 @@
 import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
 import { sep } from '@codingame/monaco-vscode-api/vscode/vs/base/common/path';
 import { raceCancellationError } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
-import { CancellationToken } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
+import { CancellationToken, CancellationTokenSource } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
 import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
 import { Emitter, AsyncEmitter, Event } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
 import { Disposable, DisposableMap, DisposableStore, combinedDisposable, toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
@@ -39,13 +39,13 @@ import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/in
 import { renderAsPlaintext } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/markdownRenderer';
 import { IViewsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/views/common/viewsService.service';
 import { ChatViewId } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat';
-import { AgentSessionProviders, backgroundAgentDisplayName, getAgentSessionProviderName } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentSessions';
-import { BugIndicatingError } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
+import { AgentSessionProviders, getAgentSessionProviderName } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentSessions';
+import { isCancellationError, BugIndicatingError } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
 import { IEditorGroupsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorGroupsService.service';
 import { LocalChatSessionUri } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/chatUri';
 import { assertNever } from '@codingame/monaco-vscode-api/vscode/vs/base/common/assert';
 import { ICommandService } from '@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands.service';
-import { Target } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/service/promptsService';
+import { Target } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/promptTypes';
 import { autorun, autorunIterableDelta } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
 import { observableFromEvent } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableFromEvent';
 import { observableSignalFromEvent } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableSignalFromEvent';
@@ -53,39 +53,39 @@ import { observableSignalFromEvent } from '@codingame/monaco-vscode-api/vscode/v
 const extensionPoint = ExtensionsRegistry.registerExtensionPoint({
     extensionPoint: "chatSessions",
     jsonSchema: {
-        description: ( localize(5508, "Contributes chat session integrations to the chat widget.")),
+        description: ( localize(6010, "Contributes chat session integrations to the chat widget.")),
         type: "array",
         items: {
             type: "object",
             additionalProperties: false,
             properties: {
                 type: {
-                    description: ( localize(5509, "Unique identifier for the type of chat session.")),
+                    description: ( localize(6011, "Unique identifier for the type of chat session.")),
                     type: "string"
                 },
                 name: {
                     description: ( localize(
-                        5510,
+                        6012,
                         "Name of the dynamically registered chat participant (eg: @agent). Must not contain whitespace."
                     )),
                     type: "string",
                     pattern: "^[\\w-]+$"
                 },
                 displayName: {
-                    description: ( localize(5511, "A longer name for this item which is used for display in menus.")),
+                    description: ( localize(6013, "A longer name for this item which is used for display in menus.")),
                     type: "string"
                 },
                 description: {
-                    description: ( localize(5512, "Description of the chat session for use in menus and tooltips.")),
+                    description: ( localize(6014, "Description of the chat session for use in menus and tooltips.")),
                     type: "string"
                 },
                 when: {
-                    description: ( localize(5513, "Condition which must be true to show this item.")),
+                    description: ( localize(6015, "Condition which must be true to show this item.")),
                     type: "string"
                 },
                 icon: {
                     description: ( localize(
-                        5514,
+                        6016,
                         "Icon identifier (codicon ID) for the chat session editor tab. For example, \"$(github)\" or \"$(cloud)\"."
                     )),
                     anyOf: [{
@@ -94,22 +94,22 @@ const extensionPoint = ExtensionsRegistry.registerExtensionPoint({
                         type: "object",
                         properties: {
                             light: {
-                                description: ( localize(5515, "Icon path when a light theme is used")),
+                                description: ( localize(6017, "Icon path when a light theme is used")),
                                 type: "string"
                             },
                             dark: {
-                                description: ( localize(5516, "Icon path when a dark theme is used")),
+                                description: ( localize(6018, "Icon path when a dark theme is used")),
                                 type: "string"
                             }
                         }
                     }]
                 },
                 order: {
-                    description: ( localize(5517, "Order in which this item should be displayed.")),
+                    description: ( localize(6019, "Order in which this item should be displayed.")),
                     type: "integer"
                 },
                 alternativeIds: {
-                    description: ( localize(5518, "Alternative identifiers for backward compatibility.")),
+                    description: ( localize(6020, "Alternative identifiers for backward compatibility.")),
                     type: "array",
                     items: {
                         type: "string"
@@ -117,87 +117,95 @@ const extensionPoint = ExtensionsRegistry.registerExtensionPoint({
                 },
                 welcomeTitle: {
                     description: ( localize(
-                        5519,
+                        6021,
                         "Title text to display in the chat welcome view for this session type."
                     )),
                     type: "string"
                 },
                 welcomeMessage: {
                     description: ( localize(
-                        5520,
+                        6022,
                         "Message text (supports markdown) to display in the chat welcome view for this session type."
                     )),
                     type: "string"
                 },
                 welcomeTips: {
                     description: ( localize(
-                        5521,
+                        6023,
                         "Tips text (supports markdown and theme icons) to display in the chat welcome view for this session type."
                     )),
                     type: "string"
                 },
                 inputPlaceholder: {
                     description: ( localize(
-                        5522,
+                        6024,
                         "Placeholder text to display in the chat input box for this session type."
                     )),
                     type: "string"
                 },
                 capabilities: {
-                    description: ( localize(5523, "Optional capabilities for this chat session.")),
+                    description: ( localize(6025, "Optional capabilities for this chat session.")),
                     type: "object",
                     additionalProperties: false,
                     properties: {
                         supportsFileAttachments: {
                             description: ( localize(
-                                5524,
+                                6026,
                                 "Whether this chat session supports attaching files or file references."
                             )),
                             type: "boolean"
                         },
                         supportsToolAttachments: {
                             description: ( localize(
-                                5525,
+                                6027,
                                 "Whether this chat session supports attaching tools or tool references."
                             )),
                             type: "boolean"
                         },
                         supportsMCPAttachments: {
-                            description: ( localize(5526, "Whether this chat session supports attaching MCP resources.")),
+                            description: ( localize(6028, "Whether this chat session supports attaching MCP resources.")),
                             type: "boolean"
                         },
                         supportsImageAttachments: {
-                            description: ( localize(5527, "Whether this chat session supports attaching images.")),
+                            description: ( localize(6029, "Whether this chat session supports attaching images.")),
                             type: "boolean"
                         },
                         supportsSearchResultAttachments: {
-                            description: ( localize(5528, "Whether this chat session supports attaching search results.")),
+                            description: ( localize(6030, "Whether this chat session supports attaching search results.")),
                             type: "boolean"
                         },
                         supportsInstructionAttachments: {
-                            description: ( localize(5529, "Whether this chat session supports attaching instructions.")),
+                            description: ( localize(6031, "Whether this chat session supports attaching instructions.")),
                             type: "boolean"
                         },
                         supportsSourceControlAttachments: {
                             description: ( localize(
-                                5530,
+                                6032,
                                 "Whether this chat session supports attaching source control changes."
                             )),
                             type: "boolean"
                         },
                         supportsProblemAttachments: {
-                            description: ( localize(5531, "Whether this chat session supports attaching problems.")),
+                            description: ( localize(6033, "Whether this chat session supports attaching problems.")),
                             type: "boolean"
                         },
                         supportsSymbolAttachments: {
-                            description: ( localize(5532, "Whether this chat session supports attaching symbols.")),
+                            description: ( localize(6034, "Whether this chat session supports attaching symbols.")),
+                            type: "boolean"
+                        },
+                        supportsPromptAttachments: {
+                            description: ( localize(6035, "Whether this chat session supports attaching prompts.")),
+                            type: "boolean"
+                        },
+                        supportsHandOffs: {
+                            description: ( localize(6036, "Whether this chat session supports hand-off prompts.")),
                             type: "boolean"
                         }
                     }
                 },
                 commands: {
                     markdownDescription: ( localize(
-                        5533,
+                        6037,
                         "Commands available for this chat session, which the user can invoke with a `/`."
                     )),
                     type: "array",
@@ -214,17 +222,17 @@ const extensionPoint = ExtensionsRegistry.registerExtensionPoint({
                         properties: {
                             name: {
                                 description: ( localize(
-                                    5534,
+                                    6038,
                                     "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(5535, "A description of this command.")),
+                                description: ( localize(6039, "A description of this command.")),
                                 type: "string"
                             },
                             when: {
-                                description: ( localize(5536, "A condition which must be true to enable this command.")),
+                                description: ( localize(6040, "A condition which must be true to enable this command.")),
                                 type: "string"
                             }
                         }
@@ -232,7 +240,7 @@ const extensionPoint = ExtensionsRegistry.registerExtensionPoint({
                 },
                 canDelegate: {
                     description: ( localize(
-                        5537,
+                        6041,
                         "Whether delegation is supported. Default is false. Note that enabling this is experimental and may not be respected at all times."
                     )),
                     type: "boolean",
@@ -240,10 +248,18 @@ const extensionPoint = ExtensionsRegistry.registerExtensionPoint({
                 },
                 customAgentTarget: {
                     description: ( localize(
-                        5538,
+                        6042,
                         "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(
+                        6043,
+                        "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
                 }
             },
             required: ["type", "name", "displayName", "description"]
@@ -313,7 +329,7 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
         this._menuService = _menuService;
         this._themeService = _themeService;
         this._labelService = _labelService;
-        this._itemsProviders = ( new Map());
+        this._itemControllers = ( new Map());
         this._contributions = ( new Map());
         this._contributionDisposables = this._register(( new DisposableMap()));
         this._contentProviders = ( new Map());
@@ -332,12 +348,14 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
         this._onRequestNotifyExtension = this._register(( new AsyncEmitter()));
         this.inProgressMap = ( new Map());
         this._sessionTypeOptions = ( new Map());
+        this._sessionTypeNewSessionOptions = ( new Map());
         this._sessionTypeIcons = ( new Map());
         this._sessionTypeWelcomeTitles = ( new Map());
         this._sessionTypeWelcomeMessages = ( new Map());
         this._sessionTypeWelcomeTips = ( new Map());
         this._sessionTypeInputPlaceholders = ( new Map());
         this._sessions = ( new ResourceMap());
+        this._resourceAliases = ( new ResourceMap());
         this._hasCanDelegateProvidersKey = ChatContextKeys.hasCanDelegateProviders.bindTo(this._contextKeyService);
         this._register(extensionPoint.setHandler(extensions => {
             for (const ext of extensions) {
@@ -359,9 +377,8 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
             this._evaluateAvailability();
         }));
         const builtinSessionProviders = [AgentSessionProviders.Local];
-        const contributedSessionProviders = observableFromEvent(this.onDidChangeAvailability, () => Array.from(( this._contributions.keys())).filter(isAgentSessionProviderType)).recomputeInitiallyAndOnChange(this._store);
+        const contributedSessionProviders = observableFromEvent(this.onDidChangeAvailability, () => Array.from(( this._contributions.keys())).filter(key => ( this._contributionDisposables.has(key)) && isAgentSessionProviderType(key))).recomputeInitiallyAndOnChange(this._store);
         this._register(autorun(reader => {
-            backgroundAgentDisplayName.read(reader);
             const activatedProviders = [...builtinSessionProviders, ...contributedSessionProviders.read(reader)];
             for (const provider of ( Object.values(AgentSessionProviders))) {
                 if (activatedProviders.includes(provider)) {
@@ -371,7 +388,11 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
                 }
             }
         }));
-        this._register(this.onDidChangeSessionItems(chatSessionType => {
+        this._register(this.onDidChangeSessionItems((
+            {
+                chatSessionType
+            }
+        ) => {
             this.updateInProgressStatus(chatSessionType).catch(error => {
                 this._logService.warn(`Failed to update progress status for '${chatSessionType}':`, error);
             });
@@ -388,11 +409,11 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
     reportInProgress(chatSessionType, count) {
         let displayName;
         if (chatSessionType === AgentSessionProviders.Local) {
-            displayName = ( localize(5539, "Local Agent"));
+            displayName = ( localize(6044, "Local Agent"));
         } else if (chatSessionType === AgentSessionProviders.Background) {
-            displayName = ( localize(5540, "Background Agent"));
+            displayName = ( localize(6045, "Background Agent"));
         } else if (chatSessionType === AgentSessionProviders.Cloud) {
-            displayName = ( localize(5541, "Cloud Agent"));
+            displayName = ( localize(6046, "Cloud Agent"));
         } else {
             displayName = this._contributions.get(chatSessionType)?.contribution.displayName;
         }
@@ -421,7 +442,13 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
         }
     }
     registerContribution(contribution, ext) {
+        this._logService.info(
+            `[ChatSessionsService] registerContribution called for type='${contribution.type}', canDelegate=${contribution.canDelegate}, when='${contribution.when}', extension='${ext.identifier.value}'`
+        );
         if (( this._contributions.has(contribution.type))) {
+            this._logService.info(
+                `[ChatSessionsService] registerContribution: type='${contribution.type}' already registered, skipping`
+            );
             return {
                 dispose: () => {}
             };
@@ -548,7 +575,7 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
             constructor() {
                 super({
                     id: `workbench.action.chat.openSessionWithPrompt.${contribution.type}`,
-                    title: ( localize2(5542, "New {0} with Prompt", contribution.displayName)),
+                    title: ( localize2(6047, "New {0} with Prompt", contribution.displayName)),
                     category: CHAT_CATEGORY,
                     icon: Codicon.plus,
                     f1: false,
@@ -562,12 +589,20 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
                 } = contribution;
                 if (chatOptions) {
                     const resource = URI.revive(chatOptions.resource);
-                    const ref = await chatService.loadSessionForResource(resource, ChatAgentLocation.Chat, CancellationToken.None);
-                    await chatService.sendRequest(resource, chatOptions.prompt, {
-                        agentIdSilent: type,
-                        attachedContext: chatOptions.attachedContext
-                    });
-                    ref?.dispose();
+                    const ref = await chatService.acquireOrLoadSession(resource, ChatAgentLocation.Chat, CancellationToken.None);
+                    try {
+                        const result = await chatService.sendRequest(resource, chatOptions.prompt, {
+                            agentIdSilent: type,
+                            attachedContext: chatOptions.attachedContext
+                        });
+                        if (result.kind === "queued") {
+                            await result.deferred;
+                        } else if (result.kind === "sent") {
+                            await result.data.responseCompletePromise;
+                        }
+                    } finally {
+                        ref?.dispose();
+                    }
                 }
             }
         }),
@@ -575,7 +610,7 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
             constructor() {
                 super({
                     id: `workbench.action.chat.openNewSessionEditor.${contribution.type}`,
-                    title: ( localize2(5543, "New {0}", contribution.displayName)),
+                    title: ( localize2(6048, "New {0}", contribution.displayName)),
                     category: CHAT_CATEGORY,
                     icon: Codicon.plus,
                     f1: true,
@@ -598,7 +633,7 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
             constructor() {
                 super({
                     id: `workbench.action.chat.openNewSessionSidebar.${contribution.type}`,
-                    title: ( localize2(5544, "New {0}", contribution.displayName)),
+                    title: ( localize2(6049, "New {0}", contribution.displayName)),
                     category: CHAT_CATEGORY,
                     icon: Codicon.plus,
                     f1: false,
@@ -630,6 +665,9 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
         } of ( this._contributions.values())) {
             const isCurrentlyRegistered = ( this._contributionDisposables.has(contribution.type));
             const shouldBeRegistered = this._isContributionAvailable(contribution);
+            this._logService.trace(
+                `[ChatSessionsService] _evaluateAvailability: type='${contribution.type}', isCurrentlyRegistered=${isCurrentlyRegistered}, shouldBeRegistered=${shouldBeRegistered}, when='${contribution.when}'`
+            );
             if (isCurrentlyRegistered && !shouldBeRegistered) {
                 this._contributionDisposables.deleteAndDispose(contribution.type);
                 this._disposeSessionsForContribution(contribution.type);
@@ -641,18 +679,25 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
         }
         if (hasChanges) {
             this._onDidChangeAvailability.fire();
-            for (const provider of ( this._itemsProviders.values())) {
-                this._onDidChangeItemsProviders.fire(provider);
+            for (const chatSessionType of ( this._itemControllers.keys())) {
+                this._onDidChangeItemsProviders.fire({
+                    chatSessionType
+                });
             }
             for (const {
                 contribution
             } of ( this._contributions.values())) {
-                this._onDidChangeSessionItems.fire(contribution.type);
+                this._onDidChangeSessionItems.fire({
+                    chatSessionType: contribution.type
+                });
             }
         }
         this._updateHasCanDelegateProvidersContextKey();
     }
     _enableContribution(contribution, ext) {
+        this._logService.info(
+            `[ChatSessionsService] _enableContribution: type='${contribution.type}', canDelegate=${contribution.canDelegate}`
+        );
         const disposableStore = ( new DisposableStore());
         this._contributionDisposables.set(contribution.type, disposableStore);
         if (contribution.canDelegate) {
@@ -741,6 +786,9 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
         return this._isContributionAvailable(contribution) ? contribution : undefined;
     }
     async activateChatSessionItemProvider(chatViewType) {
+        await this.doActivateChatSessionItemController(chatViewType);
+    }
+    async doActivateChatSessionItemController(chatViewType) {
         await this._extensionService.whenInstalledExtensionsRegistered();
         const resolvedType = this._resolveToPrimaryType(chatViewType);
         if (resolvedType) {
@@ -748,94 +796,100 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
         }
         const contribution = this._contributions.get(chatViewType)?.contribution;
         if (contribution && !this._isContributionAvailable(contribution)) {
-            return undefined;
+            return false;
         }
-        if (( this._itemsProviders.has(chatViewType))) {
-            return this._itemsProviders.get(chatViewType);
+        if (( this._itemControllers.has(chatViewType))) {
+            return true;
         }
         await this._extensionService.activateByEvent(`onChatSession:${chatViewType}`);
-        return this._itemsProviders.get(chatViewType);
+        const controller = this._itemControllers.get(chatViewType);
+        return !!controller;
     }
-    async canResolveChatSession(chatSessionResource) {
+    async canResolveChatSession(sessionType) {
         await this._extensionService.whenInstalledExtensionsRegistered();
-        const resolvedType = this._resolveToPrimaryType(chatSessionResource.scheme) || chatSessionResource.scheme;
+        const resolvedType = this._resolveToPrimaryType(sessionType) || sessionType;
         const contribution = this._contributions.get(resolvedType)?.contribution;
         if (contribution && !this._isContributionAvailable(contribution)) {
             return false;
         }
-        if (( this._contentProviders.has(chatSessionResource.scheme))) {
+        if (( this._contentProviders.has(sessionType))) {
             return true;
         }
-        await this._extensionService.activateByEvent(`onChatSession:${chatSessionResource.scheme}`);
-        return ( this._contentProviders.has(chatSessionResource.scheme));
+        await this._extensionService.activateByEvent(`onChatSession:${sessionType}`);
+        return ( this._contentProviders.has(sessionType));
     }
-    async getChatSessionItems(providersToResolve, token) {
-        const results = [];
-        const resolvedProviderTypes = ( new Set());
-        for (const contrib of this.getAllChatSessionContributions()) {
+    async tryActivateControllers(providersToResolve) {
+        await Promise.all(( this.getAllChatSessionContributions().map(async contrib => {
             if (providersToResolve && !providersToResolve.includes(contrib.type)) {
-                continue;
+                return;
             }
-            const provider = await this.activateChatSessionItemProvider(contrib.type);
-            if (!provider) {
+            if (!(await this.doActivateChatSessionItemController(contrib.type))) {
                 if (providersToResolve?.includes(contrib.type)) {
                     this._logService.trace(
                         `[ChatSessionsService] No enabled provider found for chat session type ${contrib.type}`
                     );
                 }
-                continue;
-            }
-            try {
-                const providerSessions = await raceCancellationError(provider.provideChatSessionItems(token), token);
-                this._logService.trace(
-                    `[ChatSessionsService] Resolved ${providerSessions.length} sessions for provider ${provider.chatSessionType}`
-                );
-                results.push({
-                    chatSessionType: provider.chatSessionType,
-                    items: providerSessions
-                });
-                resolvedProviderTypes.add(provider.chatSessionType);
-            } catch (error) {
-                this._logService.error(
-                    `[ChatSessionsService] Failed to resolve sessions for provider ${provider.chatSessionType}`,
-                    error
-                );
-                continue;
-            }
-        }
-        for (const [chatSessionType, provider] of this._itemsProviders) {
-            if (( resolvedProviderTypes.has(chatSessionType))) {
-                continue;
             }
-            if (providersToResolve && !providersToResolve.includes(chatSessionType)) {
-                continue;
+        })));
+    }
+    async getChatSessionItems(providersToResolve, token) {
+        await this.tryActivateControllers(providersToResolve);
+        const results = [];
+        await Promise.all(( Array.from(this._itemControllers).map(async ([chatSessionType, controllerEntry]) => {
+            const resolvedType = this._resolveToPrimaryType(chatSessionType) ?? chatSessionType;
+            if (providersToResolve && !providersToResolve.includes(resolvedType)) {
+                return;
             }
             try {
-                const providerSessions = await raceCancellationError(provider.provideChatSessionItems(token), token);
+                await controllerEntry.initialRefresh;
+                const providerSessions = controllerEntry.controller.items;
                 this._logService.trace(
-                    `[ChatSessionsService] Resolved ${providerSessions.length} sessions for built-in provider ${chatSessionType}`
+                    `[ChatSessionsService] Resolved ${providerSessions.length} sessions for provider ${resolvedType}`
                 );
                 results.push({
-                    chatSessionType,
+                    chatSessionType: resolvedType,
                     items: providerSessions
                 });
-            } catch (error) {
-                this._logService.error(
-                    `[ChatSessionsService] Failed to resolve sessions for built-in provider ${chatSessionType}`,
-                    error
-                );
-                continue;
+            } catch (err) {
+                if (!isCancellationError(err)) {
+                    this._logService.error(
+                        `[ChatSessionsService] Failed to resolve sessions for provider ${resolvedType}`,
+                        err
+                    );
+                }
             }
-        }
+        })));
         return results;
     }
-    registerChatSessionItemProvider(provider) {
-        const chatSessionType = provider.chatSessionType;
-        this._itemsProviders.set(chatSessionType, provider);
-        this._onDidChangeItemsProviders.fire(provider);
+    async refreshChatSessionItems(providersToResolve, token) {
+        await this.tryActivateControllers(providersToResolve);
+        await Promise.all(( Array.from(this._itemControllers).map(async ([chatSessionType, controllerEntry]) => {
+            try {
+                await controllerEntry.controller.refresh(token);
+            } catch (err) {
+                if (!isCancellationError(err)) {
+                    this._logService.error(
+                        `[ChatSessionsService] Failed to resolve sessions for provider ${chatSessionType}`,
+                        err
+                    );
+                }
+            }
+        })));
+    }
+    registerChatSessionItemController(chatSessionType, controller) {
         const disposables = ( new DisposableStore());
-        disposables.add(provider.onDidChangeChatSessionItems(() => {
-            this._onDidChangeSessionItems.fire(chatSessionType);
+        const initialRefreshCts = disposables.add(( new CancellationTokenSource()));
+        this._itemControllers.set(chatSessionType, {
+            controller,
+            initialRefresh: controller.refresh(initialRefreshCts.token)
+        });
+        this._onDidChangeItemsProviders.fire({
+            chatSessionType
+        });
+        disposables.add(controller.onDidChangeChatSessionItems(() => {
+            this._onDidChangeSessionItems.fire({
+                chatSessionType
+            });
         }));
         this.updateInProgressStatus(chatSessionType).catch(error => {
             this._logService.warn(
@@ -845,11 +899,14 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
         });
         return {
             dispose: () => {
+                initialRefreshCts.cancel();
                 disposables.dispose();
-                const provider = this._itemsProviders.get(chatSessionType);
-                if (provider) {
-                    this._itemsProviders.delete(chatSessionType);
-                    this._onDidChangeItemsProviders.fire(provider);
+                const controller = this._itemControllers.get(chatSessionType);
+                if (controller) {
+                    this._itemControllers.delete(chatSessionType);
+                    this._onDidChangeItemsProviders.fire({
+                        chatSessionType
+                    });
                 }
             }
         };
@@ -948,34 +1005,72 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
                     const confirmationTitle = state.confirmationMessages?.title;
                     const titleMessage = confirmationTitle && (typeof confirmationTitle === "string" ? confirmationTitle : confirmationTitle.value);
                     const descriptionValue = typeof description === "string" ? description : description.value;
-                    description = titleMessage ?? ( localize(5545, "Waiting for confirmation: {0}", descriptionValue));
+                    description = titleMessage ?? ( localize(6050, "Waiting for confirmation: {0}", descriptionValue));
                 }
             } else if (part.kind === "toolInvocationSerialized") {
                 description = part.invocationMessage;
             } else if (part.kind === "progressMessage") {
                 description = part.content;
             } else if (part.kind === "thinking") {
-                description = ( localize(5546, "Thinking..."));
+                description = ( localize(6051, "Thinking..."));
             }
         }
         return description ? renderAsPlaintext(description, {
             useLinkFormatter: true
         }) : "";
     }
+    async createNewChatSessionItem(chatSessionType, request, token) {
+        const controllerData = this._itemControllers.get(chatSessionType);
+        if (!controllerData) {
+            return undefined;
+        }
+        await controllerData.initialRefresh;
+        return controllerData.controller.newChatSessionItem?.(request, token);
+    }
     async getOrCreateChatSession(sessionResource, token) {
-        const existingSessionData = this._sessions.get(sessionResource);
-        if (existingSessionData) {
-            return existingSessionData.session;
+        {
+            const existingSessionData = this._sessions.get(sessionResource);
+            if (existingSessionData) {
+                return existingSessionData.session;
+            }
         }
-        if (!(await raceCancellationError(this.canResolveChatSession(sessionResource), token))) {
+        if (!(await raceCancellationError(this.canResolveChatSession(sessionResource.scheme), token))) {
             throw Error(`Can not find provider for ${sessionResource}`);
         }
+        {
+            const existingSessionData = this._sessions.get(sessionResource);
+            if (existingSessionData) {
+                return existingSessionData.session;
+            }
+        }
         const resolvedType = this._resolveToPrimaryType(sessionResource.scheme) || sessionResource.scheme;
         const provider = this._contentProviders.get(resolvedType);
         if (!provider) {
             throw Error(`Can not find provider for ${sessionResource}`);
         }
-        const session = await raceCancellationError(provider.provideChatSessionContent(sessionResource, token), token);
+        let session;
+        const newSessionOptions = this.getNewSessionOptionsForSessionType(resolvedType);
+        if (sessionResource.path.startsWith("/untitled") && newSessionOptions) {
+            session = {
+                sessionResource: sessionResource,
+                onWillDispose: Event.None,
+                history: [],
+                options: newSessionOptions ?? {},
+                dispose: () => {}
+            };
+        } else {
+            session = await raceCancellationError(provider.provideChatSessionContent(sessionResource, token), token);
+        }
+        for (const [optionId, value] of Object.entries(session.options ?? {})) {
+            this.setSessionOption(sessionResource, optionId, value);
+        }
+        {
+            const existingSessionData = this._sessions.get(sessionResource);
+            if (existingSessionData) {
+                session.dispose();
+                return existingSessionData.session;
+            }
+        }
         const sessionData = ( new ContributedChatSessionData(
             session,
             sessionResource.scheme,
@@ -987,22 +1082,26 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
             }
         ));
         this._sessions.set(sessionResource, sessionData);
+        this._onDidChangeSessionOptions.fire(sessionResource);
         return session;
     }
     hasAnySessionOptions(sessionResource) {
-        const session = this._sessions.get(sessionResource);
+        const session = this._sessions.get(this._resolveResource(sessionResource));
         return !!session && !!session.options && ( Object.keys(session.options)).length > 0;
     }
     getSessionOption(sessionResource, optionId) {
-        const session = this._sessions.get(sessionResource);
+        const session = this._sessions.get(this._resolveResource(sessionResource));
         return session?.getOption(optionId);
     }
     setSessionOption(sessionResource, optionId, value) {
-        const session = this._sessions.get(sessionResource);
+        const session = this._sessions.get(this._resolveResource(sessionResource));
         return !!session?.setOption(optionId, value);
     }
-    notifySessionItemsChanged(chatSessionType) {
-        this._onDidChangeSessionItems.fire(chatSessionType);
+    _resolveResource(resource) {
+        return this._resourceAliases.get(resource) ?? resource;
+    }
+    registerSessionResourceAlias(untitledResource, realResource) {
+        this._resourceAliases.set(realResource, untitledResource);
     }
     setOptionGroupsForSessionType(chatSessionType, handle, optionGroups) {
         if (optionGroups) {
@@ -1015,6 +1114,12 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
     getOptionGroupsForSessionType(chatSessionType) {
         return this._sessionTypeOptions.get(chatSessionType);
     }
+    getNewSessionOptionsForSessionType(chatSessionType) {
+        return this._sessionTypeNewSessionOptions.get(chatSessionType);
+    }
+    setNewSessionOptionsForSessionType(chatSessionType, options) {
+        this._sessionTypeNewSessionOptions.set(chatSessionType, options);
+    }
     async notifySessionOptionsChange(sessionResource, updates) {
         if (!updates.length) {
             return;
@@ -1032,7 +1137,7 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
         for (const u of updates) {
             this.setSessionOption(sessionResource, u.optionId, u.value);
         }
-        this._onDidChangeSessionOptions.fire(sessionResource);
+        this._onDidChangeSessionOptions.fire(this._resolveResource(sessionResource));
         this._logService.trace(
             `[ChatSessionsService] notifySessionOptionsChange: finished for ${sessionResource}`
         );
@@ -1065,6 +1170,10 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
         const contribution = this._contributions.get(chatSessionType)?.contribution;
         return contribution?.customAgentTarget ?? Target.Undefined;
     }
+    requiresCustomModelsForSessionType(chatSessionType) {
+        const contribution = this._contributions.get(chatSessionType)?.contribution;
+        return !!contribution?.requiresCustomModels;
+    }
     getContentProviderSchemes() {
         return Array.from(( this._contentProviders.keys()));
     }
@@ -1075,7 +1184,7 @@ function registerNewSessionInPlaceAction(type, displayName) {
         constructor() {
             super({
                 id: `workbench.action.chat.openNewChatSessionInPlace.${type}`,
-                title: ( localize2(5547, "New {0}", displayName)),
+                title: ( localize2(6052, "New {0}", displayName)),
                 category: CHAT_CATEGORY,
                 f1: false,
                 precondition: ChatContextKeys.enabled
@@ -1091,7 +1200,7 @@ function registerNewSessionInPlaceAction(type, displayName) {
             }
             await openChatSession(accessor, {
                 type: type,
-                displayName: ( localize(5548, "Chat")),
+                displayName: ( localize(6053, "Chat")),
                 position: chatSessionPosition,
                 replaceEditor: true
             });
@@ -1103,7 +1212,7 @@ function registerNewSessionExternalAction(type, displayName, commandId) {
         constructor() {
             super({
                 id: `workbench.action.chat.openNewChatSessionExternal.${type}`,
-                title: ( localize2(5549, "New {0}", displayName)),
+                title: ( localize2(6054, "New {0}", displayName)),
                 category: CHAT_CATEGORY,
                 f1: false,
                 precondition: ChatContextKeys.enabled
@@ -1146,7 +1255,7 @@ async function openChatSession(accessor, openOptions, chatSendOptions) {
                     override: ChatEditorInput.EditorID,
                     pinned: true,
                     title: {
-                        fallback: ( localize(5550, "{0}", openOptions.displayName))
+                        fallback: ( localize(6055, "{0}", openOptions.displayName))
                     }
                 };
                 if (openOptions.replaceEditor) {
@@ -1184,6 +1293,15 @@ async function openChatSession(accessor, openOptions, chatSendOptions) {
     }
     if (chatSendOptions) {
         try {
+            if (chatSendOptions.initialSessionOptions) {
+                const model = chatService.getSession(resource);
+                if (model?.contributedChatSession) {
+                    model.setContributedChatSession({
+                        ...model.contributedChatSession,
+                        initialSessionOptions: chatSendOptions.initialSessionOptions
+                    });
+                }
+            }
             await chatService.sendRequest(resource, chatSendOptions.prompt, {
                 agentIdSilent: openOptions.type,
                 attachedContext: chatSendOptions.attachedContext