@codingame/monaco-vscode-extensions-service-override 30.0.1 → 31.0.0

package/vscode/src/vs/workbench/api/browser/mainThreadChatAgents2.js

@@ -4,6 +4,7 @@ import { DeferredPromise } from '@codingame/monaco-vscode-api/vscode/vs/base/com
 import { CancellationToken } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
 import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
 import { Disposable, DisposableMap } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
 import { revive } from '@codingame/monaco-vscode-api/vscode/vs/base/common/marshalling';
 import { Schemas } from '@codingame/monaco-vscode-api/vscode/vs/base/common/network';
 import { escapeRegExpCharacters } from '@codingame/monaco-vscode-api/vscode/vs/base/common/strings';
@@ -17,12 +18,13 @@ import { ILanguageFeaturesService } from '@codingame/monaco-vscode-api/vscode/vs
 import { ExtensionIdentifier } from '@codingame/monaco-vscode-api/vscode/vs/platform/extensions/common/extensions';
 import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
 import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
+import { ITelemetryService } from '@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service';
 import { IUriIdentityService } from '@codingame/monaco-vscode-api/vscode/vs/platform/uriIdentity/common/uriIdentity.service';
 import { IChatWidgetService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service';
 import { IChatAgentService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/participants/chatAgents.service';
 import { PromptsStorage } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/service/promptsService';
 import { IPromptsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/service/promptsService.service';
-import { isValidPromptType } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/promptTypes';
+import { PromptsType, isValidPromptType } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/promptTypes';
 import { ChatRequestAgentPart } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/requestParser/chatParserTypes';
 import { ChatRequestParser } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/requestParser/chatRequestParser';
 import { getDynamicVariablesForWidget, getSelectedToolAndToolSetsForWidget } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/attachments/chatVariables';
@@ -37,10 +39,12 @@ import { ExtHostContext, MainContext } from '@codingame/monaco-vscode-api/vscode
 import { NotebookDto } from './mainThreadNotebookDto.js';
 import { isUntitledChatSession } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/chatUri';
 import { ICustomizationHarnessService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/customizationHarnessService.service';
-import { AICustomizationManagementSection } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/aiCustomizationWorkspaceService';
-import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
-import { addDynamicVariableActionId } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/widget/input/editor/chatDynamicVariablesConstant';
+import { AICustomizationManagementSection, BUILTIN_STORAGE } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/aiCustomizationWorkspaceService';
+import { IAgentPluginService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/plugins/agentPluginService.service';
+import { IWorkbenchEnvironmentService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/environment/common/environmentService.service';
 import { getAgentSessionProvider, AgentSessionProviders } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentSessions';
+import { addDynamicVariableActionId } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/widget/input/editor/chatDynamicVariablesConstant';
+import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
 
 class MainThreadChatTask {
     get onDidAddProgress() {
@@ -89,7 +93,9 @@ let MainThreadChatAgents2 = class MainThreadChatAgents2 extends Disposable {
         _promptsService,
         _languageModelToolsService,
         _customizationHarnessService,
-        _configurationService
+        _telemetryService,
+        _agentPluginService,
+        _environmentService
     ) {
         super();
         this._chatAgentService = _chatAgentService;
@@ -104,7 +110,9 @@ let MainThreadChatAgents2 = class MainThreadChatAgents2 extends Disposable {
         this._promptsService = _promptsService;
         this._languageModelToolsService = _languageModelToolsService;
         this._customizationHarnessService = _customizationHarnessService;
-        this._configurationService = _configurationService;
+        this._telemetryService = _telemetryService;
+        this._agentPluginService = _agentPluginService;
+        this._environmentService = _environmentService;
         this._agents = this._register(( new DisposableMap()));
         this._agentCompletionProviders = this._register(( new DisposableMap()));
         this._agentIdsToCompletionProviders = this._register(( new DisposableMap()));
@@ -118,14 +126,6 @@ let MainThreadChatAgents2 = class MainThreadChatAgents2 extends Disposable {
         this._activeTasks = ( new Map());
         this._unresolvedAnchors = ( new Map());
         this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostChatAgents2));
-        this._register(this._configurationService.onDidChangeConfiguration(e => {
-            if (e.affectsConfiguration("chat.customizations.providerApi.enabled")) {
-                if (!this._configurationService.getValue("chat.customizations.providerApi.enabled")) {
-                    this._customizationProviders.clearAndDisposeAll();
-                    this._customizationProviderEmitters.clearAndDisposeAll();
-                }
-            }
-        }));
         this._register(this._chatService.onDidDisposeSession(e => {
             for (const resource of e.sessionResources) {
                 this._proxy.$releaseSession(resource);
@@ -152,17 +152,24 @@ let MainThreadChatAgents2 = class MainThreadChatAgents2 extends Disposable {
             this._acceptActiveChatSession(this._chatWidgetService.lastFocusedWidget);
         }));
         this._acceptActiveChatSession(this._chatWidgetService.lastFocusedWidget);
-        void this._pushCustomAgents();
         this._register(this._promptsService.onDidChangeCustomAgents(() => {
-            void this._pushCustomAgents();
+            this._proxy.$onDidChangeCustomAgents();
         }));
-        void this._pushInstructions();
         this._register(this._promptsService.onDidChangeInstructions(() => {
-            void this._pushInstructions();
+            this._proxy.$onDidChangeInstructions();
         }));
-        void this._pushSkills();
         this._register(this._promptsService.onDidChangeSkills(() => {
-            void this._pushSkills();
+            this._proxy.$onDidChangeSkills();
+        }));
+        this._register(this._promptsService.onDidChangeSlashCommands(() => {
+            this._proxy.$onDidChangeSlashCommands();
+        }));
+        this._register(this._promptsService.onDidChangeHooks(() => {
+            this._proxy.$onDidChangeHooks();
+        }));
+        this._register(autorun(reader => {
+            this._agentPluginService.plugins.read(reader);
+            this._proxy.$onDidChangePlugins();
         }));
     }
     _acceptActiveChatSession(widget) {
@@ -170,38 +177,105 @@ let MainThreadChatAgents2 = class MainThreadChatAgents2 extends Disposable {
         const isLocal = sessionResource && getAgentSessionProvider(sessionResource) === AgentSessionProviders.Local;
         this._proxy.$acceptActiveChatSession(isLocal ? sessionResource : undefined);
     }
-    async _pushCustomAgents() {
-        try {
-            const customAgents = await this._promptsService.getCustomAgents(CancellationToken.None);
-            const dtos = ( customAgents.map(agent => ({
-                uri: agent.uri
-            })));
-            this._proxy.$acceptCustomAgents(dtos);
-        } catch (error) {
-            this._logService.error("[chat] Failed to push custom agents to extension host", error);
+    _toChatResourceSource(storage) {
+        switch (storage) {
+        case PromptsStorage.local:
+            return "local";
+        case PromptsStorage.user:
+            return "user";
+        case PromptsStorage.extension:
+            return "extension";
+        case PromptsStorage.plugin:
+            return "plugin";
         }
     }
-    async _pushInstructions() {
-        try {
-            const instructions = await this._promptsService.getInstructionFiles(CancellationToken.None);
-            const dtos = ( instructions.map(instruction => ({
-                uri: instruction.uri
-            })));
-            this._proxy.$acceptInstructions(dtos);
-        } catch (error) {
-            this._logService.error("[chat] Failed to push instructions to extension host", error);
-        }
+    _toCustomAgentDto(agent) {
+        return {
+            uri: agent.uri,
+            name: agent.name,
+            description: agent.description,
+            source: this._toChatResourceSource(agent.source.storage),
+            extensionId: agent.source.storage === PromptsStorage.extension ? agent.source.extensionId.value : undefined,
+            pluginUri: agent.source.storage === PromptsStorage.plugin ? agent.source.pluginUri : undefined,
+            sessionTypes: agent.sessionTypes,
+            argumentHint: agent.argumentHint,
+            tools: agent.tools,
+            model: agent.model,
+            userInvocable: agent.visibility.userInvocable,
+            disableModelInvocation: !agent.visibility.agentInvocable
+        };
     }
-    async _pushSkills() {
-        try {
-            const skills = (await this._promptsService.findAgentSkills(CancellationToken.None)) ?? [];
-            const dtos = ( skills.map(skill => ({
-                uri: skill.uri
-            })));
-            this._proxy.$acceptSkills(dtos);
-        } catch (error) {
-            this._logService.error("[chat] Failed to push skills to extension host", error);
-        }
+    _toInstructionDto(instruction) {
+        return {
+            uri: instruction.uri,
+            name: instruction.name,
+            description: instruction.description,
+            source: this._toChatResourceSource(instruction.storage),
+            extensionId: instruction.extension?.identifier.value,
+            pluginUri: instruction.pluginUri,
+            sessionTypes: instruction.sessionTypes,
+            pattern: instruction.pattern
+        };
+    }
+    _toSkillDto(skill) {
+        return {
+            uri: skill.uri,
+            name: skill.name,
+            description: skill.description,
+            source: this._toChatResourceSource(skill.storage),
+            extensionId: skill.extension?.identifier.value,
+            pluginUri: skill.pluginUri,
+            sessionTypes: skill.sessionTypes,
+            userInvocable: skill.userInvocable
+        };
+    }
+    _toSlashCommandDto(slashCommand) {
+        return {
+            uri: slashCommand.uri,
+            name: slashCommand.name,
+            description: slashCommand.description,
+            source: this._toChatResourceSource(slashCommand.storage),
+            extensionId: slashCommand.extension?.identifier.value,
+            pluginUri: slashCommand.pluginUri,
+            sessionTypes: slashCommand.sessionTypes,
+            argumentHint: slashCommand.argumentHint,
+            userInvocable: slashCommand.userInvocable
+        };
+    }
+    _toHookDto(hookFile) {
+        return {
+            uri: hookFile.uri,
+            sessionTypes: hookFile.sessionTypes
+        };
+    }
+    _toPluginDto(plugin) {
+        return {
+            uri: plugin.uri
+        };
+    }
+    async $provideCustomAgents(token) {
+        const customAgents = await this._promptsService.getCustomAgents(token);
+        return ( customAgents.map(agent => this._toCustomAgentDto(agent)));
+    }
+    async $provideInstructions(token) {
+        const instructions = await this._promptsService.getInstructionFiles(token);
+        return ( instructions.map(instruction => this._toInstructionDto(instruction)));
+    }
+    async $provideSkills(token) {
+        const skills = (await this._promptsService.findAgentSkills(token)) ?? [];
+        return ( skills.map(skill => this._toSkillDto(skill)));
+    }
+    async $provideSlashCommands(token) {
+        const slashCommands = await this._promptsService.getPromptSlashCommands(token);
+        return ( slashCommands.map(slashCommand => this._toSlashCommandDto(slashCommand)));
+    }
+    async $provideHooks(token) {
+        const hookFiles = await this._promptsService.listPromptFiles(PromptsType.hook, token);
+        return ( hookFiles.map(hookFile => this._toHookDto(hookFile)));
+    }
+    async $providePlugins(_token) {
+        const plugins = this._agentPluginService.plugins.get();
+        return ( plugins.map(plugin => this._toPluginDto(plugin)));
     }
     $unregisterAgent(handle) {
         this._agents.deleteAndDispose(handle);
@@ -235,21 +309,34 @@ let MainThreadChatAgents2 = class MainThreadChatAgents2 extends Disposable {
                     chatSession
                 });
                 try {
-                    const contributedSession = chatSession?.contributedChatSession;
-                    let chatSessionContext;
-                    if (contributedSession) {
-                        const chatSessionResource = contributedSession.chatSessionResource;
-                        const isUntitled = isUntitledChatSession(chatSessionResource);
-                        chatSessionContext = {
-                            chatSessionResource,
-                            isUntitled,
-                            initialSessionOptions: ChatSessionOptionsMap.toStrValueArray(contributedSession.initialSessionOptions)
-                        };
-                    }
-                    return (await this._proxy.$invokeAgent(handle, request, {
+                    const chatSessionResource = request.sessionResource;
+                    const chatSessionContext = {
+                        chatSessionResource,
+                        isUntitled: isUntitledChatSession(chatSessionResource),
+                        initialSessionOptions: ChatSessionOptionsMap.toStrValueArray(this._chatSessionService.getSessionOptions(chatSessionResource))
+                    };
+                    const rpcResult = await this._proxy.$invokeAgent(handle, request, {
                         history,
                         chatSessionContext
-                    }, token)) ?? {};
+                    }, token);
+                    if (rpcResult?.errorCallstack) {
+                        this._telemetryService.publicLogError2("chatAgentError", {
+                            callstack: rpcResult.errorCallstack,
+                            msg: rpcResult.errorDetails?.message ?? "",
+                            errorName: rpcResult.errorName ?? "",
+                            agent: id,
+                            agentExtensionId: extension.value
+                        });
+                    }
+                    if (rpcResult) {
+                        const {
+                            errorCallstack: _,
+                            errorName: _2,
+                            ...result
+                        } = rpcResult;
+                        return result;
+                    }
+                    return {};
                 } finally {
                     this._pendingProgress.delete(request.requestId);
                 }
@@ -567,10 +654,7 @@ let MainThreadChatAgents2 = class MainThreadChatAgents2 extends Disposable {
         }
     }
     async $registerChatSessionCustomizationProvider(handle, chatSessionType, metadata, extensionId) {
-        if (!this._configurationService.getValue("chat.customizations.providerApi.enabled")) {
-            this._logService.trace(
-                `[MainThreadChatAgents2] Customization provider API is disabled, ignoring registration from ${extensionId.value}`
-            );
+        if (this._environmentService.isSessionsWindow && chatSessionType !== "copilotcli") {
             return;
         }
         const extension = await this._extensionService.getExtension(extensionId.value);
@@ -600,22 +684,25 @@ let MainThreadChatAgents2 = class MainThreadChatAgents2 extends Disposable {
                 })));
             }
         };
-        const hiddenSections = metadata.unsupportedTypes?.map(type => {
-            switch (type) {
-            case "agent":
-                return AICustomizationManagementSection.Agents;
-            case "skill":
-                return AICustomizationManagementSection.Skills;
-            case "instructions":
-                return AICustomizationManagementSection.Instructions;
-            case "prompt":
-                return AICustomizationManagementSection.Prompts;
-            case "hook":
-                return AICustomizationManagementSection.Hooks;
-            default:
-                return type;
+        const typeToSection = {
+            "agent": AICustomizationManagementSection.Agents,
+            "skill": AICustomizationManagementSection.Skills,
+            "instructions": AICustomizationManagementSection.Instructions,
+            "prompt": AICustomizationManagementSection.Prompts,
+            "hook": AICustomizationManagementSection.Hooks,
+            "plugins": AICustomizationManagementSection.Plugins
+        };
+        let hiddenSections;
+        if (metadata.supportedTypes) {
+            const supportedSections = ( new Set());
+            for (const t of metadata.supportedTypes) {
+                const section = typeToSection[t];
+                if (section) {
+                    supportedSections.add(section);
+                }
             }
-        });
+            hiddenSections = ( Object.values(typeToSection)).filter(section => !( supportedSections.has(section)));
+        }
         const descriptor = {
             id: chatSessionType,
             label: metadata.label,
@@ -626,7 +713,8 @@ let MainThreadChatAgents2 = class MainThreadChatAgents2 extends Disposable {
                     PromptsStorage.local,
                     PromptsStorage.user,
                     PromptsStorage.plugin,
-                    PromptsStorage.extension
+                    PromptsStorage.extension,
+                    BUILTIN_STORAGE
                 ]
             }),
             itemProvider
@@ -645,7 +733,7 @@ let MainThreadChatAgents2 = class MainThreadChatAgents2 extends Disposable {
         }
     }
 };
-MainThreadChatAgents2 = __decorate([extHostNamedCustomer(MainContext.MainThreadChatAgents2), ( __param(1, IChatAgentService)), ( __param(2, IChatSessionsService)), ( __param(3, IChatService)), ( __param(4, ILanguageFeaturesService)), ( __param(5, IChatWidgetService)), ( __param(6, IInstantiationService)), ( __param(7, ILogService)), ( __param(8, IExtensionService)), ( __param(9, IUriIdentityService)), ( __param(10, IPromptsService)), ( __param(11, ILanguageModelToolsService)), ( __param(12, ICustomizationHarnessService)), ( __param(13, IConfigurationService))], MainThreadChatAgents2);
+MainThreadChatAgents2 = __decorate([extHostNamedCustomer(MainContext.MainThreadChatAgents2), ( __param(1, IChatAgentService)), ( __param(2, IChatSessionsService)), ( __param(3, IChatService)), ( __param(4, ILanguageFeaturesService)), ( __param(5, IChatWidgetService)), ( __param(6, IInstantiationService)), ( __param(7, ILogService)), ( __param(8, IExtensionService)), ( __param(9, IUriIdentityService)), ( __param(10, IPromptsService)), ( __param(11, ILanguageModelToolsService)), ( __param(12, ICustomizationHarnessService)), ( __param(13, ITelemetryService)), ( __param(14, IAgentPluginService)), ( __param(15, IWorkbenchEnvironmentService))], MainThreadChatAgents2);
 function computeCompletionRanges(model, position, reg) {
     const varWord = getWordAtText(position.column, reg, model.getLineContent(position.lineNumber), 0);
     if (!varWord && model.getWordUntilPosition(position).word) {

package/vscode/src/vs/workbench/api/browser/mainThreadChatDebug.js

@@ -60,6 +60,13 @@ let MainThreadChatDebug = class MainThreadChatDebug extends Disposable {
                 return uri;
             }
         }));
+        this._chatDebugService.registerAvailableSessionsFetcher(async token => {
+            const entries = await this._proxy.$getAvailableDebugSessionResources(handle, token);
+            return ( entries.map(e => ({
+                uri: URI.revive(e.uri),
+                title: e.title
+            })));
+        });
     }
     $unregisterChatDebugLogProvider(handle) {
         const disposables = this._providerDisposables.get(handle);

package/vscode/src/vs/workbench/api/browser/mainThreadChatSessions.d.ts

@@ -10,7 +10,7 @@ import { IChatWidgetService } from "@codingame/monaco-vscode-api/vscode/vs/workb
 import { IChatDebugService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatDebugService.service";
 import { IChatContentInlineReference, IChatProgress } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService";
 import { IChatService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService.service";
-import { IChatSession, IChatSessionHistoryItem, IChatSessionItem, IChatSessionProviderOptionItem, IChatSessionRequestHistoryItem, ReadonlyChatSessionOptionsMap } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService";
+import { IChatSession, IChatSessionHistoryItem, IChatSessionItem, IChatSessionProviderOptionGroup, IChatSessionProviderOptionItem, IChatSessionRequestHistoryItem, ReadonlyChatSessionOptionsMap } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService";
 import { IChatSessionsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService.service";
 import { IChatAgentRequest } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/participants/chatAgents";
 import { IChatArtifactsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/chatArtifactsService.service";
@@ -85,6 +85,8 @@ export declare class MainThreadChatSessions extends Disposable implements MainTh
     constructor(_extHostContext: IExtHostContext, _agentSessionsService: IAgentSessionsService, _chatSessionsService: IChatSessionsService, _chatService: IChatService, _chatWidgetService: IChatWidgetService, _chatTodoListService: IChatTodoListService, _chatArtifactsService: IChatArtifactsService, _chatDebugService: IChatDebugService, _dialogService: IDialogService, _editorService: IEditorService, editorGroupService: IEditorGroupsService, _logService: ILogService, _instantiationService: IInstantiationService);
     private _getHandleForSessionType;
     $registerChatSessionItemController(handle: number, chatSessionType: string): void;
+    private _refreshControllerInputState;
+    private _applyOptionGroups;
     private getController;
     $updateChatSessionItems(controllerHandle: number, change: IChatSessionItemsChange): Promise<void>;
     $addOrUpdateChatSessionItem(controllerHandle: number, item: Dto<IChatSessionItem>): Promise<void>;
@@ -105,6 +107,7 @@ export declare class MainThreadChatSessions extends Disposable implements MainTh
     $handleProgressComplete(handle: number, sessionResource: UriComponents, requestId: string): void;
     $handleAnchorResolve(handle: number, sesssionResource: UriComponents, requestId: string, requestHandle: string, anchor: Dto<IChatContentInlineReference>): void;
     $onDidChangeChatSessionProviderOptions(handle: number): void;
+    $updateChatSessionInputState(controllerHandle: number, sessionResource: UriComponents, optionGroups: readonly IChatSessionProviderOptionGroup[]): void;
     private _refreshProviderOptions;
     dispose(): void;
     /**

package/vscode/src/vs/workbench/api/browser/mainThreadChatSessions.js

@@ -135,7 +135,7 @@ class ObservableChatSession extends Disposable {
                         return confirmInterrupt();
                     }
                     return this._dialogService.confirm({
-                        message: ( localize(2554, "Are you sure you want to interrupt the active session?"))
+                        message: ( localize(2549, "Are you sure you want to interrupt the active session?"))
                     }).then(confirmed => {
                         if (confirmed.confirmed) {
                             return confirmInterrupt();
@@ -382,6 +382,13 @@ let MainThreadChatSessionItemController = class MainThreadChatSessionItemControl
             this.addOrUpdateItem(existing);
         }
     }
+    async getNewChatSessionInputState(sessionResource, token) {
+        const optionGroups = await this._proxy.$provideChatSessionInputState(this._handle, sessionResource, token);
+        if (!optionGroups?.length) {
+            return undefined;
+        }
+        return optionGroups;
+    }
 };
 MainThreadChatSessionItemController = ( __decorate([( __param(3, IChatService)), ( __param(4, ILogService))], MainThreadChatSessionItemController));
 class MainThreadChatSessionItem {
@@ -496,6 +503,27 @@ let MainThreadChatSessions = class MainThreadChatSessions extends Disposable {
             controller,
             dispose: () => disposables.dispose()
         });
+        this._refreshControllerInputState(handle, chatSessionType);
+    }
+    _refreshControllerInputState(handle, chatSessionType) {
+        this._proxy.$provideChatSessionInputState(handle, undefined, CancellationToken.None).then(optionGroups => {
+            if (optionGroups?.length) {
+                this._applyOptionGroups(handle, chatSessionType, undefined, optionGroups);
+            }
+        }).catch(
+            err => this._logService.error("Error fetching chat session input state", err)
+        );
+    }
+    _applyOptionGroups(handle, chatSessionType, sessionResourceComponents, optionGroups) {
+        this._chatSessionsService.setOptionGroupsForSessionType(chatSessionType, handle, optionGroups);
+        if (sessionResourceComponents) {
+            const sessionResource = URI.revive(sessionResourceComponents);
+            optionGroups.forEach(group => {
+                if (group.selected) {
+                    this._chatSessionsService.setSessionOption(sessionResource, group.id, group.selected);
+                }
+            });
+        }
     }
     getController(handle) {
         const registration = this._itemControllerRegistrations.get(handle);
@@ -547,7 +575,7 @@ let MainThreadChatSessions = class MainThreadChatSessions extends Disposable {
             const options = {
                 title: {
                     preferred: originalEditor?.getName() || undefined,
-                    fallback: ( localize(2555, "{0}", contribution?.displayName))
+                    fallback: ( localize(2550, "{0}", contribution?.displayName))
                 }
             };
             const newSession = await this._chatSessionsService.getOrCreateChatSession(URI.revive(modifiedResource), CancellationToken.None);
@@ -710,22 +738,25 @@ let MainThreadChatSessions = class MainThreadChatSessions extends Disposable {
         }
         this._refreshProviderOptions(handle, sessionType);
     }
+    $updateChatSessionInputState(controllerHandle, sessionResource, optionGroups) {
+        const registration = this._itemControllerRegistrations.get(controllerHandle);
+        if (!registration) {
+            this._logService.warn(
+                `No controller found for handle ${controllerHandle} when updating input state`
+            );
+            return;
+        }
+        this._applyOptionGroups(
+            controllerHandle,
+            registration.chatSessionType,
+            sessionResource,
+            optionGroups
+        );
+    }
     _refreshProviderOptions(handle, chatSessionScheme) {
         this._proxy.$provideChatSessionProviderOptions(handle, CancellationToken.None).then(options => {
             if (options?.optionGroups && options.optionGroups.length) {
-                const groupsWithCallbacks = ( options.optionGroups.map(group => ({
-                    ...group,
-                    onSearch: group.searchable ? async (query, token) => {
-                        return await this._proxy.$invokeOptionGroupSearch(handle, group.id, query, token);
-                    } : undefined
-                })));
-                this._chatSessionsService.setOptionGroupsForSessionType(chatSessionScheme, handle, groupsWithCallbacks);
-            }
-            if (options?.newSessionOptions) {
-                this._chatSessionsService.setNewSessionOptionsForSessionType(
-                    chatSessionScheme,
-                    ChatSessionOptionsMap.fromRecord(options.newSessionOptions)
-                );
+                this._chatSessionsService.setOptionGroupsForSessionType(chatSessionScheme, handle, [...options.optionGroups]);
             }
         }).catch(err => this._logService.error("Error fetching chat session options", err));
     }

package/vscode/src/vs/workbench/api/browser/mainThreadComments.js

@@ -456,7 +456,7 @@ class MainThreadCommentController extends Disposable {
         };
     }
 }
-const commentsViewIcon = registerIcon("comments-view-icon", Codicon.commentDiscussion, ( localize(2556, "View icon of the comments view.")));
+const commentsViewIcon = registerIcon("comments-view-icon", Codicon.commentDiscussion, ( localize(2551, "View icon of the comments view.")));
 let MainThreadComments = class MainThreadComments extends Disposable {
     constructor(
         extHostContext,

package/vscode/src/vs/workbench/api/browser/mainThreadCustomEditors.js

@@ -405,7 +405,7 @@ let MainThreadCustomEditorModel = MainThreadCustomEditorModel_1 = class MainThre
             this._register(workingCopyService.registerWorkingCopy(this));
             this._register(extensionService.onWillStop(e => {
                 e.veto(true, ( localize(
-                    2557,
+                    2552,
                     "An extension provided editor for '{0}' is still open that would close otherwise.",
                     this.name
                 )));
@@ -473,7 +473,7 @@ let MainThreadCustomEditorModel = MainThreadCustomEditorModel_1 = class MainThre
         this._undoService.pushElement({
             type: UndoRedoElementType.Resource,
             resource: this._editorResource,
-            label: label ?? ( localize(2558, "Edit")),
+            label: label ?? ( localize(2553, "Edit")),
             code: "undoredo.customEditorEdit",
             undo: () => this.undo(),
             redo: () => this.redo()

package/vscode/src/vs/workbench/api/browser/mainThreadEditSessionIdentityParticipant.js

@@ -14,7 +14,7 @@ class ExtHostEditSessionIdentityCreateParticipant {
     }
     async participate(workspaceFolder, token) {
         const p = ( new Promise((resolve, reject) => {
-            setTimeout(() => reject(( new Error(( localize(2559, "Aborted onWillCreateEditSessionIdentity-event after 10000ms"))))), this.timeout);
+            setTimeout(() => reject(( new Error(( localize(2554, "Aborted onWillCreateEditSessionIdentity-event after 10000ms"))))), this.timeout);
             this._proxy.$onWillCreateEditSessionIdentity(workspaceFolder.uri, token, this.timeout).then(resolve, reject);
         }));
         return raceCancellationError(p, token);

package/vscode/src/vs/workbench/api/browser/mainThreadExtensionService.js

@@ -111,7 +111,7 @@ let MainThreadExtensionService = class MainThreadExtensionService {
             this._notificationService.notify({
                 severity: Severity.Error,
                 message: ( localize(
-                    2560,
+                    2555,
                     "Cannot activate the '{0}' extension because it depends on the '{1}' extension, which is not loaded. Would you like to reload the window to load the extension?",
                     extName,
                     missingInstalledDependency.manifest.displayName || missingInstalledDependency.manifest.name
@@ -119,7 +119,7 @@ let MainThreadExtensionService = class MainThreadExtensionService {
                 actions: {
                     primary: [toAction({
                         id: "reload",
-                        label: ( localize(2561, "Reload Window")),
+                        label: ( localize(2556, "Reload Window")),
                         run: () => this._hostService.reload()
                     })]
                 }
@@ -130,7 +130,7 @@ let MainThreadExtensionService = class MainThreadExtensionService {
                 this._notificationService.notify({
                     severity: Severity.Error,
                     message: ( localize(
-                        2562,
+                        2557,
                         "Cannot activate the '{0}' extension because it depends on the '{1}' extension which is not supported in the current workspace",
                         extName,
                         missingInstalledDependency.manifest.displayName || missingInstalledDependency.manifest.name
@@ -140,7 +140,7 @@ let MainThreadExtensionService = class MainThreadExtensionService {
                 this._notificationService.notify({
                     severity: Severity.Error,
                     message: ( localize(
-                        2563,
+                        2558,
                         "Cannot activate the '{0}' extension because it depends on the '{1}' extension which is not supported in Restricted Mode",
                         extName,
                         missingInstalledDependency.manifest.displayName || missingInstalledDependency.manifest.name
@@ -148,7 +148,7 @@ let MainThreadExtensionService = class MainThreadExtensionService {
                     actions: {
                         primary: [toAction({
                             id: "manageWorkspaceTrust",
-                            label: ( localize(2564, "Manage Workspace Trust")),
+                            label: ( localize(2559, "Manage Workspace Trust")),
                             run: () => this._commandService.executeCommand("workbench.trust.manage")
                         })]
                     }
@@ -157,7 +157,7 @@ let MainThreadExtensionService = class MainThreadExtensionService {
                 this._notificationService.notify({
                     severity: Severity.Error,
                     message: ( localize(
-                        2565,
+                        2560,
                         "Cannot activate the '{0}' extension because it depends on the '{1}' extension which is disabled. Would you like to enable the extension and reload the window?",
                         extName,
                         missingInstalledDependency.manifest.displayName || missingInstalledDependency.manifest.name
@@ -165,7 +165,7 @@ let MainThreadExtensionService = class MainThreadExtensionService {
                     actions: {
                         primary: [toAction({
                             id: "enable",
-                            label: ( localize(2566, "Enable and Reload")),
+                            label: ( localize(2561, "Enable and Reload")),
                             enabled: true,
                             run: () => this._extensionEnablementService.setEnablement(
                                 [missingInstalledDependency],
@@ -178,7 +178,7 @@ let MainThreadExtensionService = class MainThreadExtensionService {
                 this._notificationService.notify({
                     severity: Severity.Error,
                     message: ( localize(
-                        2567,
+                        2562,
                         "Cannot activate the '{0}' extension because it depends on the '{1}' extension which is disabled.",
                         extName,
                         missingInstalledDependency.manifest.displayName || missingInstalledDependency.manifest.name
@@ -199,7 +199,7 @@ let MainThreadExtensionService = class MainThreadExtensionService {
             this._notificationService.notify({
                 severity: Severity.Error,
                 message: ( localize(
-                    2568,
+                    2563,
                     "Cannot activate the '{0}' extension because it depends on the '{1}' extension from '{2}', which is not installed. Would you like to install the extension and reload the window?",
                     extName,
                     dependencyExtension.displayName,
@@ -208,14 +208,14 @@ let MainThreadExtensionService = class MainThreadExtensionService {
                 actions: {
                     primary: [toAction({
                         id: "install",
-                        label: ( localize(2569, "Install and Reload")),
+                        label: ( localize(2564, "Install and Reload")),
                         run: () => this._extensionsWorkbenchService.install(dependencyExtension).then(() => this._hostService.reload(), e => this._notificationService.error(e))
                     })]
                 }
             });
         } else {
             this._notificationService.error(( localize(
-                2570,
+                2565,
                 "Cannot activate the '{0}' extension because it depends on an unknown '{1}' extension.",
                 extName,
                 missingDependency