@codingame/monaco-vscode-katex-common 28.4.1 → 29.0.0

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

@@ -1,12 +1,12 @@
 
 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 { AsyncIterableProducer, raceCancellationError } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
 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 { Emitter, Event } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
 import { Disposable, DisposableMap, DisposableStore, combinedDisposable, toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
-import { ResourceMap } from '@codingame/monaco-vscode-api/vscode/vs/base/common/map';
+import { ResourceMap, ResourceSet } from '@codingame/monaco-vscode-api/vscode/vs/base/common/map';
 import { Schemas } from '@codingame/monaco-vscode-api/vscode/vs/base/common/network';
 import { joinPath } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
 import { ThemeIcon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/themables';
@@ -42,51 +42,52 @@ import { ChatViewId } from '@codingame/monaco-vscode-api/vscode/vs/workbench/con
 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 { isUntitledChatSession, 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/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';
+import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
 
 const extensionPoint = ExtensionsRegistry.registerExtensionPoint({
     extensionPoint: "chatSessions",
     jsonSchema: {
-        description: ( localize(6010, "Contributes chat session integrations to the chat widget.")),
+        description: ( localize(6143, "Contributes chat session integrations to the chat widget.")),
         type: "array",
         items: {
             type: "object",
             additionalProperties: false,
             properties: {
                 type: {
-                    description: ( localize(6011, "Unique identifier for the type of chat session.")),
+                    description: ( localize(6144, "Unique identifier for the type of chat session.")),
                     type: "string"
                 },
                 name: {
                     description: ( localize(
-                        6012,
+                        6145,
                         "Name of the dynamically registered chat participant (eg: @agent). Must not contain whitespace."
                     )),
                     type: "string",
                     pattern: "^[\\w-]+$"
                 },
                 displayName: {
-                    description: ( localize(6013, "A longer name for this item which is used for display in menus.")),
+                    description: ( localize(6146, "A longer name for this item which is used for display in menus.")),
                     type: "string"
                 },
                 description: {
-                    description: ( localize(6014, "Description of the chat session for use in menus and tooltips.")),
+                    description: ( localize(6147, "Description of the chat session for use in menus and tooltips.")),
                     type: "string"
                 },
                 when: {
-                    description: ( localize(6015, "Condition which must be true to show this item.")),
+                    description: ( localize(6148, "Condition which must be true to show this item.")),
                     type: "string"
                 },
                 icon: {
                     description: ( localize(
-                        6016,
-                        "Icon identifier (codicon ID) for the chat session editor tab. For example, \"$(github)\" or \"$(cloud)\"."
+                        6149,
+                        "Icon identifier (codicon ID) for the chat session editor tab. For example, \"{0}\" or \"{1}\".",
+                        "$(github)",
+                        "$(cloud)"
                     )),
                     anyOf: [{
                         type: "string"
@@ -94,22 +95,22 @@ const extensionPoint = ExtensionsRegistry.registerExtensionPoint({
                         type: "object",
                         properties: {
                             light: {
-                                description: ( localize(6017, "Icon path when a light theme is used")),
+                                description: ( localize(6150, "Icon path when a light theme is used")),
                                 type: "string"
                             },
                             dark: {
-                                description: ( localize(6018, "Icon path when a dark theme is used")),
+                                description: ( localize(6151, "Icon path when a dark theme is used")),
                                 type: "string"
                             }
                         }
                     }]
                 },
                 order: {
-                    description: ( localize(6019, "Order in which this item should be displayed.")),
+                    description: ( localize(6152, "Order in which this item should be displayed.")),
                     type: "integer"
                 },
                 alternativeIds: {
-                    description: ( localize(6020, "Alternative identifiers for backward compatibility.")),
+                    description: ( localize(6153, "Alternative identifiers for backward compatibility.")),
                     type: "array",
                     items: {
                         type: "string"
@@ -117,95 +118,95 @@ const extensionPoint = ExtensionsRegistry.registerExtensionPoint({
                 },
                 welcomeTitle: {
                     description: ( localize(
-                        6021,
+                        6154,
                         "Title text to display in the chat welcome view for this session type."
                     )),
                     type: "string"
                 },
                 welcomeMessage: {
                     description: ( localize(
-                        6022,
+                        6155,
                         "Message text (supports markdown) to display in the chat welcome view for this session type."
                     )),
                     type: "string"
                 },
                 welcomeTips: {
                     description: ( localize(
-                        6023,
+                        6156,
                         "Tips text (supports markdown and theme icons) to display in the chat welcome view for this session type."
                     )),
                     type: "string"
                 },
                 inputPlaceholder: {
                     description: ( localize(
-                        6024,
+                        6157,
                         "Placeholder text to display in the chat input box for this session type."
                     )),
                     type: "string"
                 },
                 capabilities: {
-                    description: ( localize(6025, "Optional capabilities for this chat session.")),
+                    description: ( localize(6158, "Optional capabilities for this chat session.")),
                     type: "object",
                     additionalProperties: false,
                     properties: {
                         supportsFileAttachments: {
                             description: ( localize(
-                                6026,
+                                6159,
                                 "Whether this chat session supports attaching files or file references."
                             )),
                             type: "boolean"
                         },
                         supportsToolAttachments: {
                             description: ( localize(
-                                6027,
+                                6160,
                                 "Whether this chat session supports attaching tools or tool references."
                             )),
                             type: "boolean"
                         },
                         supportsMCPAttachments: {
-                            description: ( localize(6028, "Whether this chat session supports attaching MCP resources.")),
+                            description: ( localize(6161, "Whether this chat session supports attaching MCP resources.")),
                             type: "boolean"
                         },
                         supportsImageAttachments: {
-                            description: ( localize(6029, "Whether this chat session supports attaching images.")),
+                            description: ( localize(6162, "Whether this chat session supports attaching images.")),
                             type: "boolean"
                         },
                         supportsSearchResultAttachments: {
-                            description: ( localize(6030, "Whether this chat session supports attaching search results.")),
+                            description: ( localize(6163, "Whether this chat session supports attaching search results.")),
                             type: "boolean"
                         },
                         supportsInstructionAttachments: {
-                            description: ( localize(6031, "Whether this chat session supports attaching instructions.")),
+                            description: ( localize(6164, "Whether this chat session supports attaching instructions.")),
                             type: "boolean"
                         },
                         supportsSourceControlAttachments: {
                             description: ( localize(
-                                6032,
+                                6165,
                                 "Whether this chat session supports attaching source control changes."
                             )),
                             type: "boolean"
                         },
                         supportsProblemAttachments: {
-                            description: ( localize(6033, "Whether this chat session supports attaching problems.")),
+                            description: ( localize(6166, "Whether this chat session supports attaching problems.")),
                             type: "boolean"
                         },
                         supportsSymbolAttachments: {
-                            description: ( localize(6034, "Whether this chat session supports attaching symbols.")),
+                            description: ( localize(6167, "Whether this chat session supports attaching symbols.")),
                             type: "boolean"
                         },
                         supportsPromptAttachments: {
-                            description: ( localize(6035, "Whether this chat session supports attaching prompts.")),
+                            description: ( localize(6168, "Whether this chat session supports attaching prompts.")),
                             type: "boolean"
                         },
                         supportsHandOffs: {
-                            description: ( localize(6036, "Whether this chat session supports hand-off prompts.")),
+                            description: ( localize(6169, "Whether this chat session supports hand-off prompts.")),
                             type: "boolean"
                         }
                     }
                 },
                 commands: {
                     markdownDescription: ( localize(
-                        6037,
+                        6170,
                         "Commands available for this chat session, which the user can invoke with a `/`."
                     )),
                     type: "array",
@@ -222,17 +223,17 @@ const extensionPoint = ExtensionsRegistry.registerExtensionPoint({
                         properties: {
                             name: {
                                 description: ( localize(
-                                    6038,
+                                    6171,
                                     "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(6039, "A description of this command.")),
+                                description: ( localize(6172, "A description of this command.")),
                                 type: "string"
                             },
                             when: {
-                                description: ( localize(6040, "A condition which must be true to enable this command.")),
+                                description: ( localize(6173, "A condition which must be true to enable this command.")),
                                 type: "string"
                             }
                         }
@@ -240,7 +241,7 @@ const extensionPoint = ExtensionsRegistry.registerExtensionPoint({
                 },
                 canDelegate: {
                     description: ( localize(
-                        6041,
+                        6174,
                         "Whether delegation is supported. Default is false. Note that enabling this is experimental and may not be respected at all times."
                     )),
                     type: "boolean",
@@ -248,18 +249,26 @@ const extensionPoint = ExtensionsRegistry.registerExtensionPoint({
                 },
                 customAgentTarget: {
                     description: ( localize(
-                        6042,
+                        6175,
                         "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,
+                        6176,
                         "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
+                },
+                autoAttachReferences: {
+                    description: ( localize(
+                        6177,
+                        "Whether to automatically attach instruction files to chat requests for this session type."
+                    )),
+                    type: "boolean",
+                    default: false
                 }
             },
             required: ["type", "name", "displayName", "description"]
@@ -275,6 +284,9 @@ class ContributedChatSessionData extends Disposable {
     getOption(optionId) {
         return this._optionsCache.get(optionId);
     }
+    getAllOptions() {
+        return this._optionsCache.entries();
+    }
     setOption(optionId, value) {
         this._optionsCache.set(optionId, value);
     }
@@ -285,12 +297,7 @@ class ContributedChatSessionData extends Disposable {
         this.resource = resource;
         this.options = options;
         this.onWillDispose = onWillDispose;
-        this._optionsCache = ( new Map());
-        if (options) {
-            for (const [key, value] of Object.entries(options)) {
-                this._optionsCache.set(key, value);
-            }
-        }
+        this._optionsCache = ( new Map(options));
         this._register(this.session.onWillDispose(() => {
             this.onWillDispose(this.resource);
         }));
@@ -309,9 +316,6 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
     get onDidChangeOptionGroups() {
         return this._onDidChangeOptionGroups.event;
     }
-    get onRequestNotifyExtension() {
-        return this._onRequestNotifyExtension.event;
-    }
     constructor(
         _logService,
         _chatAgentService,
@@ -345,21 +349,15 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
         this._onDidChangeContentProviderSchemes = this._register(( new Emitter()));
         this._onDidChangeSessionOptions = this._register(( new Emitter()));
         this._onDidChangeOptionGroups = this._register(( new Emitter()));
-        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) {
-                if (!isProposedApiEnabled(ext.description, "chatSessionsProvider")) {
+                if (!isProposedApiEnabled(ext.description)) {
                     continue;
                 }
                 if (!Array.isArray(ext.value)) {
@@ -388,15 +386,6 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
                 }
             }
         }));
-        this._register(this.onDidChangeSessionItems((
-            {
-                chatSessionType
-            }
-        ) => {
-            this.updateInProgressStatus(chatSessionType).catch(error => {
-                this._logService.warn(`Failed to update progress status for '${chatSessionType}':`, error);
-            });
-        }));
         this._register(this._labelService.registerFormatter({
             scheme: Schemas.copilotPr,
             formatting: {
@@ -407,31 +396,26 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
         }));
     }
     reportInProgress(chatSessionType, count) {
-        let displayName;
-        if (chatSessionType === AgentSessionProviders.Local) {
-            displayName = ( localize(6044, "Local Agent"));
-        } else if (chatSessionType === AgentSessionProviders.Background) {
-            displayName = ( localize(6045, "Background Agent"));
-        } else if (chatSessionType === AgentSessionProviders.Cloud) {
-            displayName = ( localize(6046, "Cloud Agent"));
-        } else {
-            displayName = this._contributions.get(chatSessionType)?.contribution.displayName;
-        }
-        if (displayName) {
-            this.inProgressMap.set(displayName, count);
+        if (!( this._itemControllers.has(chatSessionType))) {
+            this._logService.warn(
+                `Attempted to report in-progress status for unknown chat session type '${chatSessionType}'`
+            );
         }
+        this.inProgressMap.set(chatSessionType, count);
         this._onDidChangeInProgress.fire();
     }
     getInProgress() {
-        return ( Array.from(this.inProgressMap.entries()).map(([displayName, count]) => ({
-            displayName,
+        return ( Array.from(this.inProgressMap.entries()).map(([chatSessionType, count]) => ({
+            chatSessionType,
             count
         })));
     }
     async updateInProgressStatus(chatSessionType) {
         try {
-            const results = await this.getChatSessionItems([chatSessionType], CancellationToken.None);
-            const items = results.flatMap(r => r.items);
+            const items = [];
+            for await (const result of this.getChatSessionItems([chatSessionType], CancellationToken.None)) {
+                items.push(...result.items);
+            }
             const inProgress = items.filter(item => item.status && isSessionInProgressStatus(item.status));
             this.reportInProgress(chatSessionType, inProgress.length);
         } catch (error) {
@@ -442,16 +426,14 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
         }
     }
     registerContribution(contribution, ext) {
-        this._logService.info(
+        this._logService.trace(
             `[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(
+            this._logService.trace(
                 `[ChatSessionsService] registerContribution: type='${contribution.type}' already registered, skipping`
             );
-            return {
-                dispose: () => {}
-            };
+            return Disposable.None;
         }
         if (contribution.when) {
             const whenExpr = ContextKeyExpr.deserialize(contribution.when);
@@ -475,32 +457,6 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
                 this._alternativeIdMap.set(altId, contribution.type);
             }
         }
-        let icon;
-        if (contribution.icon) {
-            if (typeof contribution.icon === "string") {
-                icon = contribution.icon.startsWith("$(") && contribution.icon.endsWith(")") ? ThemeIcon.fromString(contribution.icon) : ThemeIcon.fromId(contribution.icon);
-            } else {
-                icon = {
-                    dark: joinPath(ext.extensionLocation, contribution.icon.dark),
-                    light: joinPath(ext.extensionLocation, contribution.icon.light)
-                };
-            }
-        }
-        if (icon) {
-            this._sessionTypeIcons.set(contribution.type, icon);
-        }
-        if (contribution.welcomeTitle) {
-            this._sessionTypeWelcomeTitles.set(contribution.type, contribution.welcomeTitle);
-        }
-        if (contribution.welcomeMessage) {
-            this._sessionTypeWelcomeMessages.set(contribution.type, contribution.welcomeMessage);
-        }
-        if (contribution.welcomeTips) {
-            this._sessionTypeWelcomeTips.set(contribution.type, contribution.welcomeTips);
-        }
-        if (contribution.inputPlaceholder) {
-            this._sessionTypeInputPlaceholders.set(contribution.type, contribution.inputPlaceholder);
-        }
         this._evaluateAvailability();
         return {
             dispose: () => {
@@ -512,11 +468,6 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
                         }
                     }
                 }
-                this._sessionTypeIcons.delete(contribution.type);
-                this._sessionTypeWelcomeTitles.delete(contribution.type);
-                this._sessionTypeWelcomeMessages.delete(contribution.type);
-                this._sessionTypeWelcomeTips.delete(contribution.type);
-                this._sessionTypeInputPlaceholders.delete(contribution.type);
                 this._contributionDisposables.deleteAndDispose(contribution.type);
                 this._updateHasCanDelegateProvidersContextKey();
             }
@@ -575,7 +526,7 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
             constructor() {
                 super({
                     id: `workbench.action.chat.openSessionWithPrompt.${contribution.type}`,
-                    title: ( localize2(6047, "New {0} with Prompt", contribution.displayName)),
+                    title: ( localize2(6178, "New {0} with Prompt", contribution.displayName)),
                     category: CHAT_CATEGORY,
                     icon: Codicon.plus,
                     f1: false,
@@ -610,7 +561,7 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
             constructor() {
                 super({
                     id: `workbench.action.chat.openNewSessionEditor.${contribution.type}`,
-                    title: ( localize2(6048, "New {0}", contribution.displayName)),
+                    title: ( localize2(6179, "New {0}", contribution.displayName)),
                     category: CHAT_CATEGORY,
                     icon: Codicon.plus,
                     f1: true,
@@ -633,7 +584,7 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
             constructor() {
                 super({
                     id: `workbench.action.chat.openNewSessionSidebar.${contribution.type}`,
-                    title: ( localize2(6049, "New {0}", contribution.displayName)),
+                    title: ( localize2(6180, "New {0}", contribution.displayName)),
                     category: CHAT_CATEGORY,
                     icon: Codicon.plus,
                     f1: false,
@@ -658,7 +609,9 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
         }));
     }
     _evaluateAvailability() {
-        let hasChanges = false;
+        const newlyEnabledChatSessionTypes = ( new Set());
+        const newlyDisabledChatSessionTypes = ( new Set());
+        const disposedChatSessions = ( new ResourceSet());
         for (const {
             contribution,
             extension
@@ -670,32 +623,34 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
             );
             if (isCurrentlyRegistered && !shouldBeRegistered) {
                 this._contributionDisposables.deleteAndDispose(contribution.type);
-                this._disposeSessionsForContribution(contribution.type);
-                hasChanges = true;
+                for (const sessionResource of this._disposeSessionsForContribution(contribution.type)) {
+                    disposedChatSessions.add(sessionResource);
+                }
+                newlyDisabledChatSessionTypes.add(contribution.type);
             } else if (!isCurrentlyRegistered && shouldBeRegistered) {
-                this._enableContribution(contribution, extension);
-                hasChanges = true;
+                if (extension) {
+                    this._enableContribution(contribution, extension);
+                }
+                newlyEnabledChatSessionTypes.add(contribution.type);
             }
         }
-        if (hasChanges) {
+        if (newlyEnabledChatSessionTypes.size > 0 || newlyDisabledChatSessionTypes.size > 0) {
             this._onDidChangeAvailability.fire();
-            for (const chatSessionType of ( this._itemControllers.keys())) {
+            for (const chatSessionType of [...newlyEnabledChatSessionTypes, ...newlyDisabledChatSessionTypes]) {
                 this._onDidChangeItemsProviders.fire({
                     chatSessionType
                 });
             }
-            for (const {
-                contribution
-            } of ( this._contributions.values())) {
+            if (disposedChatSessions.size > 0) {
                 this._onDidChangeSessionItems.fire({
-                    chatSessionType: contribution.type
+                    removed: Array.from(disposedChatSessions)
                 });
             }
         }
         this._updateHasCanDelegateProvidersContextKey();
     }
     _enableContribution(contribution, ext) {
-        this._logService.info(
+        this._logService.trace(
             `[ChatSessionsService] _enableContribution: type='${contribution.type}', canDelegate=${contribution.canDelegate}`
         );
         const disposableStore = ( new DisposableStore());
@@ -724,15 +679,10 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
                 sessionData.dispose();
             }
         }
+        return sessionsToDispose;
     }
     _registerAgent(contribution, ext) {
-        const {
-            type: id,
-            name,
-            displayName,
-            description
-        } = contribution;
-        const storedIcon = this._sessionTypeIcons.get(id);
+        const storedIcon = this.getContributionIcon(ext, contribution);
         const icons = ThemeIcon.isThemeIcon(storedIcon) ? {
             themeIcon: storedIcon,
             icon: undefined,
@@ -743,11 +693,12 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
         } : {
             themeIcon: Codicon.sendToRemoteAgent
         };
+        const id = contribution.type;
         const agentData = {
             id,
-            name,
-            fullName: displayName,
-            description: description,
+            name: contribution.name,
+            fullName: contribution.displayName,
+            description: contribution.description,
             isDefault: false,
             isCore: false,
             isDynamic: true,
@@ -768,7 +719,9 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
         return this._chatAgentService.registerAgent(id, agentData);
     }
     getAllChatSessionContributions() {
-        return Array.from(( this._contributions.values()), x => x.contribution).filter(contribution => this._isContributionAvailable(contribution));
+        return ( Array.from(( this._contributions.values())).filter(entry => this._isContributionAvailable(entry.contribution)).map(
+            entry => this.resolveChatSessionContribution(entry.extension, entry.contribution)
+        ));
     }
     _updateHasCanDelegateProvidersContextKey() {
         const hasCanDelegate = this.getAllChatSessionContributions().filter(c => c.canDelegate);
@@ -779,11 +732,60 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
         this._hasCanDelegateProvidersKey.set(canDelegateEnabled);
     }
     getChatSessionContribution(chatSessionType) {
-        const contribution = this._contributions.get(chatSessionType)?.contribution;
-        if (!contribution) {
+        const entry = this._contributions.get(chatSessionType);
+        if (!entry) {
             return undefined;
         }
-        return this._isContributionAvailable(contribution) ? contribution : undefined;
+        if (!this._isContributionAvailable(entry.contribution)) {
+            return undefined;
+        }
+        return this.resolveChatSessionContribution(entry.extension, entry.contribution);
+    }
+    resolveChatSessionContribution(ext, contribution) {
+        return {
+            ...contribution,
+            icon: this.resolveIconForCurrentColorTheme(this.getContributionIcon(ext, contribution))
+        };
+    }
+    getContributionIcon(ext, contribution) {
+        if (!contribution.icon) {
+            return undefined;
+        }
+        if (typeof contribution.icon === "string") {
+            return contribution.icon.startsWith("$(") && contribution.icon.endsWith(")") ? ThemeIcon.fromString(contribution.icon) : ThemeIcon.fromId(contribution.icon);
+        }
+        return {
+            dark: ext ? joinPath(ext.extensionLocation, contribution.icon.dark) : ( URI.parse(contribution.icon.dark)),
+            light: ext ? joinPath(ext.extensionLocation, contribution.icon.light) : ( URI.parse(contribution.icon.light))
+        };
+    }
+    resolveIconForCurrentColorTheme(rawIcon) {
+        if (!rawIcon) {
+            return undefined;
+        }
+        if (ThemeIcon.isThemeIcon(rawIcon)) {
+            return rawIcon;
+        } else if (isDark(this._themeService.getColorTheme().type)) {
+            return rawIcon.dark;
+        } else {
+            return rawIcon.light;
+        }
+    }
+    registerChatSessionContribution(contribution) {
+        if (( this._contributions.has(contribution.type))) {
+            return {
+                dispose: () => {}
+            };
+        }
+        this._contributions.set(contribution.type, {
+            contribution,
+            extension: undefined
+        });
+        this._onDidChangeAvailability.fire();
+        return toDisposable(() => {
+            this._contributions.delete(contribution.type);
+            this._onDidChangeAvailability.fire();
+        });
     }
     async activateChatSessionItemProvider(chatViewType) {
         await this.doActivateChatSessionItemController(chatViewType);
@@ -832,24 +834,46 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
             }
         })));
     }
-    async getChatSessionItems(providersToResolve, token) {
+    getChatSessionItems(providersToResolve, token) {
+        return new AsyncIterableProducer(async writer => {
+            await raceCancellationError(this.tryActivateControllers(providersToResolve), token);
+            await Promise.all(
+                Array.from(this._itemControllers, async ([chatSessionType, controllerEntry]) => {
+                    const resolvedType = this._resolveToPrimaryType(chatSessionType) ?? chatSessionType;
+                    if (providersToResolve && !providersToResolve.includes(resolvedType)) {
+                        return;
+                    }
+                    try {
+                        await raceCancellationError(controllerEntry.initialRefresh, token);
+                        const providerSessions = controllerEntry.controller.items;
+                        this._logService.trace(
+                            `[ChatSessionsService] Resolved ${providerSessions.length} sessions for provider ${resolvedType}`
+                        );
+                        writer.emitOne({
+                            chatSessionType: resolvedType,
+                            items: providerSessions
+                        });
+                    } catch (err) {
+                        if (!isCancellationError(err)) {
+                            this._logService.error(
+                                `[ChatSessionsService] Failed to resolve sessions for provider ${resolvedType}`,
+                                err
+                            );
+                        }
+                    }
+                })
+            );
+        });
+    }
+    async refreshChatSessionItems(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 {
-                await controllerEntry.initialRefresh;
-                const providerSessions = controllerEntry.controller.items;
-                this._logService.trace(
-                    `[ChatSessionsService] Resolved ${providerSessions.length} sessions for provider ${resolvedType}`
-                );
-                results.push({
-                    chatSessionType: resolvedType,
-                    items: providerSessions
-                });
+                await controllerEntry.controller.refresh(token);
             } catch (err) {
                 if (!isCancellationError(err)) {
                     this._logService.error(
@@ -859,22 +883,9 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
                 }
             }
         })));
-        return results;
     }
-    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
-                    );
-                }
-            }
-        })));
+    getRegisteredChatSessionItemProviders() {
+        return [...( new Set(( Array.from(( this._itemControllers.keys())).map(key => this._resolveToPrimaryType(key) ?? key))))];
     }
     registerChatSessionItemController(chatSessionType, controller) {
         const disposables = ( new DisposableStore());
@@ -886,17 +897,10 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
         this._onDidChangeItemsProviders.fire({
             chatSessionType
         });
-        disposables.add(controller.onDidChangeChatSessionItems(() => {
-            this._onDidChangeSessionItems.fire({
-                chatSessionType
-            });
+        disposables.add(controller.onDidChangeChatSessionItems(e => {
+            this._onDidChangeSessionItems.fire(e);
+            this.updateInProgressStatus(chatSessionType);
         }));
-        this.updateInProgressStatus(chatSessionType).catch(error => {
-            this._logService.warn(
-                `Failed to update initial progress status for '${chatSessionType}':`,
-                error
-            );
-        });
         return {
             dispose: () => {
                 initialRefreshCts.cancel();
@@ -908,6 +912,7 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
                         chatSessionType
                     });
                 }
+                this.updateInProgressStatus(chatSessionType);
             }
         };
     }
@@ -936,45 +941,6 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
             }
         };
     }
-    registerChatModelChangeListeners(chatService, chatSessionType, onChange) {
-        const disposableStore = ( new DisposableStore());
-        const chatModelsICareAbout = ( chatService.chatModels.map(
-            models => Array.from(models).filter(model => model.sessionResource.scheme === chatSessionType)
-        ));
-        const listeners = ( new ResourceMap());
-        const autoRunDisposable = autorunIterableDelta(reader => chatModelsICareAbout.read(reader), (
-            {
-                addedValues,
-                removedValues
-            }
-        ) => {
-            removedValues.forEach(removed => {
-                const listener = listeners.get(removed.sessionResource);
-                if (listener) {
-                    listeners.delete(removed.sessionResource);
-                    listener.dispose();
-                }
-            });
-            addedValues.forEach(added => {
-                const requestChangeListener = ( added.lastRequestObs.map(
-                    last => last?.response && observableSignalFromEvent("chatSessions.modelRequestChangeListener", last.response.onDidChange)
-                ));
-                const modelChangeListener = observableSignalFromEvent("chatSessions.modelChangeListener", added.onDidChange);
-                listeners.set(added.sessionResource, autorun(reader => {
-                    requestChangeListener.read(reader)?.read(reader);
-                    modelChangeListener.read(reader);
-                    onChange();
-                }));
-            });
-        });
-        disposableStore.add(toDisposable(() => {
-            for (const listener of ( listeners.values())) {
-                listener.dispose();
-            }
-        }));
-        disposableStore.add(autoRunDisposable);
-        return disposableStore;
-    }
     getInProgressSessionDescription(chatModel) {
         const requests = chatModel.getRequests();
         if (requests.length === 0) {
@@ -1005,14 +971,14 @@ 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(6050, "Waiting for confirmation: {0}", descriptionValue));
+                    description = titleMessage ?? ( localize(6181, "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(6051, "Thinking..."));
+                description = ( localize(6182, "Thinking..."));
             }
         }
         return description ? renderAsPlaintext(description, {
@@ -1050,7 +1016,7 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
         }
         let session;
         const newSessionOptions = this.getNewSessionOptionsForSessionType(resolvedType);
-        if (sessionResource.path.startsWith("/untitled") && newSessionOptions) {
+        if (isUntitledChatSession(sessionResource) && newSessionOptions) {
             session = {
                 sessionResource: sessionResource,
                 onWillDispose: Event.None,
@@ -1061,8 +1027,10 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
         } else {
             session = await raceCancellationError(provider.provideChatSessionContent(sessionResource, token), token);
         }
-        for (const [optionId, value] of Object.entries(session.options ?? {})) {
-            this.setSessionOption(sessionResource, optionId, value);
+        if (session.options) {
+            for (const [optionId, value] of session.options) {
+                this.setSessionOption(sessionResource, optionId, value);
+            }
         }
         {
             const existingSessionData = this._sessions.get(sessionResource);
@@ -1082,20 +1050,56 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
             }
         ));
         this._sessions.set(sessionResource, sessionData);
-        this._onDidChangeSessionOptions.fire(sessionResource);
+        if (session.options) {
+            this._onDidChangeSessionOptions.fire({
+                sessionResource,
+                updates: session.options
+            });
+        }
         return session;
     }
     hasAnySessionOptions(sessionResource) {
         const session = this._sessions.get(this._resolveResource(sessionResource));
-        return !!session && !!session.options && ( Object.keys(session.options)).length > 0;
+        return !!session && !!session.options && session.options.size > 0;
+    }
+    getSessionOptions(sessionResource) {
+        const session = this._sessions.get(this._resolveResource(sessionResource));
+        if (!session) {
+            return undefined;
+        }
+        const result = ( new Map());
+        for (const [key, value] of session.getAllOptions()) {
+            result.set(key, typeof value === "string" ? value : value.id);
+        }
+        return result.size > 0 ? result : undefined;
     }
     getSessionOption(sessionResource, optionId) {
         const session = this._sessions.get(this._resolveResource(sessionResource));
         return session?.getOption(optionId);
     }
     setSessionOption(sessionResource, optionId, value) {
+        return this.updateSessionOptions(sessionResource, ( new Map([[optionId, value]])));
+    }
+    updateSessionOptions(sessionResource, updates) {
         const session = this._sessions.get(this._resolveResource(sessionResource));
-        return !!session?.setOption(optionId, value);
+        if (!session) {
+            return false;
+        }
+        let didChange = false;
+        for (const [optionId, value] of updates) {
+            const existingValue = session.getOption(optionId);
+            if (existingValue !== value) {
+                session.setOption(optionId, value);
+                didChange = true;
+            }
+        }
+        if (didChange) {
+            this._onDidChangeSessionOptions.fire({
+                sessionResource,
+                updates: updates
+            });
+        }
+        return didChange;
     }
     _resolveResource(resource) {
         return this._resourceAliases.get(resource) ?? resource;
@@ -1115,52 +1119,14 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
         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;
-        }
-        this._logService.trace(
-            `[ChatSessionsService] notifySessionOptionsChange: starting for ${sessionResource}, ${updates.length} update(s): [${( updates.map(u => u.optionId)).join(", ")}]`
-        );
-        await this._onRequestNotifyExtension.fireAsync({
-            sessionResource,
-            updates
-        }, CancellationToken.None);
-        this._logService.trace(
-            `[ChatSessionsService] notifySessionOptionsChange: fireAsync completed for ${sessionResource}`
-        );
-        for (const u of updates) {
-            this.setSessionOption(sessionResource, u.optionId, u.value);
-        }
-        this._onDidChangeSessionOptions.fire(this._resolveResource(sessionResource));
-        this._logService.trace(
-            `[ChatSessionsService] notifySessionOptionsChange: finished for ${sessionResource}`
-        );
-    }
-    getIconForSessionType(chatSessionType) {
-        const sessionTypeIcon = this._sessionTypeIcons.get(chatSessionType);
-        if (ThemeIcon.isThemeIcon(sessionTypeIcon)) {
-            return sessionTypeIcon;
-        }
-        if (isDark(this._themeService.getColorTheme().type)) {
-            return sessionTypeIcon?.dark;
-        } else {
-            return sessionTypeIcon?.light;
+        const options = this._sessionTypeNewSessionOptions.get(chatSessionType);
+        if (!options || options.size === 0) {
+            return undefined;
         }
+        return ( new Map(options));
     }
-    getWelcomeTitleForSessionType(chatSessionType) {
-        return this._sessionTypeWelcomeTitles.get(chatSessionType);
-    }
-    getWelcomeMessageForSessionType(chatSessionType) {
-        return this._sessionTypeWelcomeMessages.get(chatSessionType);
-    }
-    getInputPlaceholderForSessionType(chatSessionType) {
-        return this._sessionTypeInputPlaceholders.get(chatSessionType);
+    setNewSessionOptionsForSessionType(chatSessionType, options) {
+        this._sessionTypeNewSessionOptions.set(chatSessionType, ( new Map(options)));
     }
     getCapabilitiesForSessionType(chatSessionType) {
         const contribution = this._contributions.get(chatSessionType)?.contribution;
@@ -1174,6 +1140,22 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
         const contribution = this._contributions.get(chatSessionType)?.contribution;
         return !!contribution?.requiresCustomModels;
     }
+    supportsDelegationForSessionType(chatSessionType) {
+        const contribution = this._contributions.get(chatSessionType)?.contribution;
+        return contribution?.supportsDelegation !== false;
+    }
+    sessionSupportsFork(sessionResource) {
+        const session =
+        this._sessions.get(sessionResource) ?? this._sessions.get(this._resolveResource(sessionResource));
+        return !!session?.session.forkSession;
+    }
+    async forkChatSession(sessionResource, request, token) {
+        const session = this._sessions.get(this._resolveResource(sessionResource));
+        if (!session?.session.forkSession) {
+            throw ( new Error(`Session ${( sessionResource.toString())} does not support forking`));
+        }
+        return session.session.forkSession(request, token);
+    }
     getContentProviderSchemes() {
         return Array.from(( this._contentProviders.keys()));
     }
@@ -1184,7 +1166,7 @@ function registerNewSessionInPlaceAction(type, displayName) {
         constructor() {
             super({
                 id: `workbench.action.chat.openNewChatSessionInPlace.${type}`,
-                title: ( localize2(6052, "New {0}", displayName)),
+                title: ( localize2(6183, "New {0}", displayName)),
                 category: CHAT_CATEGORY,
                 f1: false,
                 precondition: ChatContextKeys.enabled
@@ -1200,7 +1182,7 @@ function registerNewSessionInPlaceAction(type, displayName) {
             }
             await openChatSession(accessor, {
                 type: type,
-                displayName: ( localize(6053, "Chat")),
+                displayName: ( localize(6184, "Chat")),
                 position: chatSessionPosition,
                 replaceEditor: true
             });
@@ -1212,7 +1194,7 @@ function registerNewSessionExternalAction(type, displayName, commandId) {
         constructor() {
             super({
                 id: `workbench.action.chat.openNewChatSessionExternal.${type}`,
-                title: ( localize2(6054, "New {0}", displayName)),
+                title: ( localize2(6185, "New {0}", displayName)),
                 category: CHAT_CATEGORY,
                 f1: false,
                 precondition: ChatContextKeys.enabled
@@ -1255,7 +1237,7 @@ async function openChatSession(accessor, openOptions, chatSendOptions) {
                     override: ChatEditorInput.EditorID,
                     pinned: true,
                     title: {
-                        fallback: ( localize(6055, "{0}", openOptions.displayName))
+                        fallback: ( localize(6186, "{0}", openOptions.displayName))
                     }
                 };
                 if (openOptions.replaceEditor) {
@@ -1315,9 +1297,6 @@ async function openChatSession(accessor, openOptions, chatSendOptions) {
     }
 }
 function getResourceForNewChatSession(options) {
-    if (options.chatResource) {
-        return URI.revive(options.chatResource);
-    }
     const isRemoteSession = options.type !== AgentSessionProviders.Local;
     if (isRemoteSession) {
         return ( URI.from({
@@ -1329,7 +1308,7 @@ function getResourceForNewChatSession(options) {
     if (isEditorPosition) {
         return ChatEditorInput.getNewEditorUri();
     }
-    return LocalChatSessionUri.forSession(generateUuid());
+    return LocalChatSessionUri.getNewSessionUri();
 }
 function isAgentSessionProviderType(type) {
     return ( Object.values(AgentSessionProviders)).includes(type);