@codingame/monaco-vscode-chat-service-override 32.0.1 → 33.0.4

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

@@ -0,0 +1,2934 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Event } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { Disposable, DisposableMap, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { Schemas } from '@codingame/monaco-vscode-api/vscode/vs/base/common/network';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { isMacintosh } from '@codingame/monaco-vscode-api/vscode/vs/base/common/platform';
+import { PolicyCategory } from '@codingame/monaco-vscode-api/vscode/vs/base/common/policy';
+import { AgentHostOTelDbSpanExporterEnabledSettingId, AgentHostOTelOutfileSettingId, AgentHostOTelCaptureContentSettingId, AgentHostOTelOtlpEndpointSettingId, AgentHostOTelExporterTypeSettingId, AgentHostOTelEnabledSettingId, AgentHostCustomTerminalToolEnabledSettingId, AgentHostAhpJsonlLoggingSettingId, AgentHostIpcLoggingSettingId, AgentHostClaudeAgentSdkPathSettingId, AgentHostEnabledSettingId } from '../../../../platform/agentHost/common/agentService.js';
+import '../../../../platform/networkFilter/common/networkFilterService.js';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { AgentNetworkDomainSettingId } from '@codingame/monaco-vscode-katex-common/vscode/vs/platform/networkFilter/common/settings';
+import { AgentSandboxSettingId, AgentSandboxEnabledValue } from '@codingame/monaco-vscode-api/vscode/vs/platform/sandbox/common/settings';
+import { registerEditorFeature } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/editorFeatures';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { AccessibleViewRegistry } from '@codingame/monaco-vscode-api/vscode/vs/platform/accessibility/browser/accessibleViewRegistry';
+import { registerAction2 } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions';
+import { CommandsRegistry } from '@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands';
+import { Extensions as Extensions$1, ConfigurationScope } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configurationRegistry';
+import { SyncDescriptor } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/descriptors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/extensions';
+import { IContextKeyService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service';
+import { mcpGalleryServiceUrlConfig, mcpGalleryServiceEnablementConfig, mcpAppsEnabledConfig, mcpAutoStartConfig, McpAutoStartValue, mcpAccessConfig, McpAccessValue } from '@codingame/monaco-vscode-api/vscode/vs/platform/mcp/common/mcpManagement';
+import product from '@codingame/monaco-vscode-api/vscode/vs/platform/product/common/product';
+import { Registry } from '@codingame/monaco-vscode-api/vscode/vs/platform/registry/common/platform';
+import { EditorPaneDescriptor } from '@codingame/monaco-vscode-api/vscode/vs/workbench/browser/editor';
+import { Extensions as Extensions$2 } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/configuration';
+import { ITelemetryService } from '@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service';
+import { registerWorkbenchContribution2, WorkbenchPhase } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions';
+import { EditorExtensions } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/editor';
+import { IWorkbenchAssignmentService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/assignment/common/assignmentService.service';
+import { ChatEntitlement } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/chat/common/chatEntitlementService';
+import { IChatEntitlementService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/chat/common/chatEntitlementService.service';
+import { IEditorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service';
+import { RegisteredEditorPriority } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorResolverService';
+import { IEditorResolverService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorResolverService.service';
+import { IPathService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/path/common/pathService.service';
+import { IViewsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/views/common/viewsService.service';
+import { AssistedTypes, AddConfigurationType } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/browser/mcpCommandsAddConfiguration';
+import { mcpDiscoverySection, allDiscoverySources, discoverySourceSettingsLabel, mcpServerSamplingSection, mcpServerCollisionBehaviorSection, McpCollisionBehavior } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpConfiguration';
+import '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/participants/chatAgents';
+import '@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/chat/common/widget/chatColors';
+import '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatModes';
+import { IChatModeService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatModes.service';
+import { ChatResponseResourceWorkbenchContribution } from '../common/widget/chatResponseResourceFileSystemProvider.js';
+import { IChatService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService.service';
+import '../common/chatService/chatServiceImpl.js';
+import { IChatSessionsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService.service';
+import '../common/participants/chatSlashCommands.js';
+import '../common/tools/chatArtifactsService.js';
+import '../common/tools/chatTodoListService.js';
+import '../common/model/chatTransferService.js';
+import '@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/chat/common/widget/chatWidgetHistoryService';
+import { ChatConfiguration, ChatPermissionLevel, ChatNotificationMode, ChatAgentLocation } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
+import '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModels';
+import '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModelStats';
+import { ILanguageModelToolsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService.service';
+import '@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/chat/browser/tools/chatToolRiskAssessmentService';
+import { agentPluginDiscoveryRegistry } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/plugins/agentPluginService';
+import { ChatPromptFilesExtensionPointHandler } from '../common/promptSyntax/chatPromptFilesContribution.js';
+import { PromptsConfig, isTildePath } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/config/config';
+import { DEFAULT_HOOK_FILE_PATHS, DEFAULT_SKILL_SOURCE_FOLDERS, SKILL_FILENAME, AGENTS_SOURCE_FOLDER, COPILOT_USER_AGENTS_SOURCE_FOLDER, CLAUDE_AGENTS_SOURCE_FOLDER, AGENT_FILE_EXTENSION, LEGACY_MODE_DEFAULT_SOURCE_FOLDER, LEGACY_MODE_FILE_EXTENSION, PROMPT_DEFAULT_SOURCE_FOLDER, PROMPT_FILE_EXTENSION, DEFAULT_INSTRUCTIONS_SOURCE_FOLDERS, INSTRUCTIONS_DEFAULT_SOURCE_FOLDER, INSTRUCTION_FILE_EXTENSION } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/config/promptFileLocations';
+import { PromptLanguageFeaturesProvider } from './promptSyntax/promptFileContributions.js';
+import { HOOK_DOCUMENTATION_URL, SKILL_DOCUMENTATION_URL, AGENT_DOCUMENTATION_URL, PROMPT_DOCUMENTATION_URL, INSTRUCTIONS_DOCUMENTATION_URL, PromptsType, PromptFileSource } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/promptTypes';
+import { HOOK_SCHEMA_URI, hookFileSchema } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/hookSchema';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { Extensions } from '@codingame/monaco-vscode-api/vscode/vs/platform/jsonschemas/common/jsonContributionRegistry';
+import '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/service/promptsServiceImpl';
+import { LanguageModelToolsExtensionPointHandler } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsContribution';
+import './telemetry/chatModelCountTelemetry.js';
+import { BuiltinToolsContribution } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/builtinTools/tools';
+import { RenameToolContribution } from './tools/renameTool.js';
+import { UsagesToolContribution } from './tools/usagesTool.js';
+import '../common/voiceChatService.js';
+import { registerChatAccessibilityActions } from './actions/chatAccessibilityActions.js';
+import { PanelChatAccessibilityHelp, QuickChatAccessibilityHelp, EditsChatAccessibilityHelp, AgentChatAccessibilityHelp } from './actions/chatAccessibilityHelp.js';
+import { ModeOpenChatGlobalAction, registerChatActions } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/actions/chatActions';
+import { CodeBlockActionRendering, registerChatCodeBlockActions, registerChatCodeCompareBlockActions } from './actions/chatCodeblockActions.js';
+import { ChatContextContributions } from '@codingame/monaco-vscode-xterm-addons-common/vscode/vs/workbench/contrib/chat/browser/actions/chatContext';
+import { registerChatContextActions } from './actions/chatContextActions.js';
+import { ChatCopyActionRendering, registerChatCopyActions } from './actions/chatCopyActions.js';
+import { registerChatDeveloperActions } from './actions/chatDeveloperActions.js';
+import { registerChatExecuteActions } from '@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/chat/browser/actions/chatExecuteActions';
+import { registerChatFileTreeActions } from './actions/chatFileTreeActions.js';
+import { ChatGettingStartedContribution } from './actions/chatGettingStarted.js';
+import { registerChatExportActions } from './actions/chatImportExport.js';
+import { registerLanguageModelActions } from './actions/chatLanguageModelActions.js';
+import { registerChatPluginActions } from './actions/chatPluginActions.js';
+import { registerMoveActions } from './actions/chatMoveActions.js';
+import { registerNewChatActions } from './actions/chatNewActions.js';
+import { registerChatPromptNavigationActions } from './actions/chatPromptNavigationActions.js';
+import { registerChatQueueActions } from './actions/chatQueueActions.js';
+import { registerQuickChatActions } from './actions/chatQuickInputActions.js';
+import { ChatAgentRecommendation } from './actions/chatAgentRecommendationActions.js';
+import { registerChatTitleActions } from '@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/chat/browser/actions/chatTitleActions';
+import { registerChatElicitationActions } from '@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/chat/browser/actions/chatElicitationActions';
+import { registerChatToolActions } from '@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/chat/browser/actions/chatToolActions';
+import { ChatTransferContribution } from './actions/chatTransfer.js';
+import { registerChatOpenAgentDebugPanelAction } from './actions/chatOpenAgentDebugPanelAction.js';
+import '../common/chatDebugServiceImpl.js';
+import { ChatDebugEditor } from './chatDebug/chatDebugEditor.js';
+import { PromptsDebugContribution } from './promptsDebugContribution.js';
+import { ChatDebugEditorInput, ChatDebugEditorInputSerializer } from './chatDebug/chatDebugEditorInput.js';
+import './agentSessions/agentSessions.contribution.js';
+import { ChatContextKeys } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/actions/chatContextKeys';
+import { ChatViewId, isIChatViewViewContext, isIChatResourceViewContext } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat';
+import { IChatWidgetService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service';
+import './accessibility/chatAccessibilityService.js';
+import '@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/chat/browser/attachments/chatAttachmentModel';
+import '@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/chat/browser/widget/input/chatInputNotificationService';
+import './attachments/chatAttachmentResolveService.js';
+import '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/strings';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
+import { ChatInputBoxContentProvider } from './widget/input/editor/chatEditorInputContentProvider.js';
+import { ChatEditingEditorAccessibility } from './chatEditing/chatEditingEditorAccessibility.js';
+import { registerChatEditorActions } from './chatEditing/chatEditingEditorActions.js';
+import { ChatEditingEditorContextKeys } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chatEditing/chatEditingEditorContextKeys';
+import { ChatEditingEditorOverlay } from './chatEditing/chatEditingEditorOverlay.js';
+import './chatEditing/chatEditingServiceImpl.js';
+import { ChatEditingNotebookFileSystemProviderContrib } from './chatEditing/notebook/chatEditingNotebookFileSystemProvider.js';
+import { ChatEditor } from './widgetHosts/editor/chatEditor.js';
+import { ChatEditorInput, ChatEditorInputSerializer } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/widgetHosts/editor/chatEditorInput';
+import './widget/chatLayoutService.js';
+import { ChatLanguageModelsDataContribution } from './languageModelsConfigurationService.js';
+import './chatManagement/chatManagement.contribution.js';
+import './aiCustomization/aiCustomizationWorkspaceService.js';
+import './aiCustomization/customizationHarnessService.js';
+import './aiCustomization/aiCustomizationManagement.contribution.js';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/service/promptsService';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/themables';
+import '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/extensions/common/extensions';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/json';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/map';
+import '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/hookCompatibility';
+import '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/hookTypes';
+import './aiCustomization/aiCustomizationIcons.js';
+import '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/aiCustomization/aiCustomizationManagement';
+import './chatOutputItemRenderer.js';
+import { ChatExtensionPointHandler, ChatCompatibilityNotifier } from './chatParticipant.contribution.js';
+import { ChatPasteProvidersFeature } from '@codingame/monaco-vscode-xterm-addons-common/vscode/vs/workbench/contrib/chat/browser/widget/input/editor/chatPasteProviders';
+import './widgetHosts/chatQuick.js';
+import { ChatResponseAccessibleView } from './accessibility/chatResponseAccessibleView.js';
+import { ChatTerminalOutputAccessibleView } from './accessibility/chatTerminalOutputAccessibleView.js';
+import { ChatSetupContribution, ChatTeardownContribution } from './chatSetup/chatSetupContributions.js';
+import { HasByokModelsContribution } from './hasByokModelsContribution.js';
+import { ChatStatusBarEntry } from './chatStatus/chatStatusEntry.js';
+import '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/attachments/chatVariables';
+import { ChatWidget } from '@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/chat/browser/widget/chatWidget';
+import { ChatDynamicVariableModel } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/attachments/chatDynamicVariables';
+import { ChatImplicitContextContribution } from '@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/chat/browser/attachments/chatImplicitContext';
+import './widget/input/editor/chatInputCompletions.js';
+import './widget/input/editor/agentHostInputCompletions.js';
+import './widget/input/editor/chatInputEditorContrib.js';
+import './widget/input/editor/chatInputEditorHover.js';
+import './tools/languageModelToolsConfirmationService.js';
+import { globalAutoApproveDescription } from './tools/languageModelToolsService.js';
+import './tools/toolResultCompressorService.js';
+import { ConfiguredAgentPluginDiscovery, MarketplaceAgentPluginDiscovery, ExtensionAgentPluginDiscovery, CopilotCliAgentPluginDiscovery } from '../common/plugins/agentPluginServiceImpl.js';
+import '../common/plugins/pluginMarketplaceService.js';
+import '../common/plugins/workspacePluginSettingsService.js';
+import { AgentPluginRecommendations } from './claudePluginRecommendations.js';
+import { AgentPluginEditor } from './agentPluginEditor/agentPluginEditor.js';
+import { AgentPluginEditorInput } from './agentPluginEditor/agentPluginEditorInput.js';
+import './agentPluginRepositoryService.js';
+import './pluginGitCommandService.js';
+import './pluginInstallService.js';
+import { PluginAutoUpdate } from './pluginAutoUpdate.js';
+import './promptSyntax/promptCodingAgentActionContribution.js';
+import './promptSyntax/promptToolsCodeLensProvider.js';
+import { ChatSlashCommandsContribution, ChatSessionOptionSlashCommandsContribution } from './chatSlashCommands.js';
+import './planReviewFeedback/planReviewFeedbackEditorContribution.js';
+import { registerPlanReviewFeedbackEditorActions } from './planReviewFeedback/planReviewFeedbackEditorActions.js';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/uuid';
+import { PluginUrlHandler } from './pluginUrlHandler.js';
+import { PromptUrlHandler } from './promptSyntax/promptUrlHandler.js';
+import { UserToolSetsContributions, ConfigureToolSets } from '@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/chat/browser/tools/toolSetsContribution';
+import { ChatViewsWelcomeHandler } from './viewsWelcome/chatViewsWelcomeHandler.js';
+import './widget/chatWidgetService.js';
+import { ChatWindowNotifier } from './chatWindowNotifier.js';
+import { ChatRepoInfoContribution } from './chatRepoInfo.js';
+import { VALID_PROMPT_FOLDER_PATTERN } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/utils/promptFilesLocator';
+import './chatTipService.js';
+import { ChatQueuePickerRendering } from './widget/input/chatQueuePickerActionItem.js';
+import { ExploreAgentDefaultModel } from './exploreAgentDefaultModel.js';
+import { PlanAgentDefaultModel } from './planAgentDefaultModel.js';
+import { UtilitySmallModelContribution, UtilityModelContribution } from './utilityModelContribution.js';
+import './chatImageCarouselService.js';
+import { browserChatToolReferenceNames } from '../../browserView/common/browserChatToolReferenceNames.js';
+import '../../notebook/browser/controller/chat/notebook.chat.contribution.js';
+import { observableFromEvent } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableFromEvent';
+import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
+
+CommandsRegistry.registerCommand("_chat.notifyQuestionCarouselAnswer", (accessor, resolveId, answers) => {
+    accessor.get(IChatService).notifyQuestionCarouselAnswer("", resolveId, answers);
+});
+const toolReferenceNameEnumValues = [];
+const toolReferenceNameEnumDescriptions = [];
+const jsonContributionRegistry = ( Registry.as(Extensions.JSONContribution));
+jsonContributionRegistry.registerSchema(HOOK_SCHEMA_URI, hookFileSchema);
+const configurationRegistry = ( Registry.as(Extensions$1.Configuration));
+configurationRegistry.registerConfiguration({
+    id: "chatSidebar",
+    title: ( localize(5806, "Chat")),
+    type: "object",
+    properties: {
+        "chat.experimentalSessionsWindowOverride": {
+            type: "boolean",
+            description: ( localize(
+                5807,
+                "When true, enables sessions-window-specific behavior for extensions."
+            )),
+            default: false,
+            tags: ["experimental"],
+            agentsWindow: {
+                default: true
+            }
+        },
+        "chat.fontSize": {
+            type: "number",
+            description: ( localize(5808, "Controls the font size in pixels in chat messages.")),
+            default: 13,
+            minimum: 6,
+            maximum: 100
+        },
+        "chat.fontFamily": {
+            type: "string",
+            description: ( localize(5809, "Controls the font family in chat messages.")),
+            default: "default"
+        },
+        "chat.editor.fontSize": {
+            type: "number",
+            description: ( localize(5810, "Controls the font size in pixels in chat codeblocks.")),
+            default: isMacintosh ? 12 : 14
+        },
+        "chat.editor.fontFamily": {
+            type: "string",
+            description: ( localize(5811, "Controls the font family in chat codeblocks.")),
+            default: "default"
+        },
+        "chat.editor.fontWeight": {
+            type: "string",
+            description: ( localize(5812, "Controls the font weight in chat codeblocks.")),
+            default: "default"
+        },
+        "chat.editor.wordWrap": {
+            type: "string",
+            description: ( localize(5813, "Controls whether lines should wrap in chat codeblocks.")),
+            default: "off",
+            enum: ["on", "off"]
+        },
+        "chat.editor.lineHeight": {
+            type: "number",
+            description: ( localize(
+                5814,
+                "Controls the line height in pixels in chat codeblocks. Use 0 to compute the line height from the font size."
+            )),
+            default: 0
+        },
+        [ChatConfiguration.AgentStatusEnabled]: {
+            type: "string",
+            enum: ["hidden", "badge", "compact"],
+            enumDescriptions: [( localize(5815, "The agent status indicator is hidden from the title bar.")), ( localize(5816, "Shows the agent status as a badge next to the command center.")), ( localize(
+                5817,
+                "Replaces the command center search box with a compact agent status indicator and unified chat widget."
+            ))],
+            markdownDescription: ( localize(
+                5818,
+                "Controls how the 'Agent Status' indicator appears in the title bar command center. When set to `hidden`, the indicator is not shown. Other values show the indicator and automatically enable {0}. The unread and in-progress session indicators require {1} to be enabled.",
+                "`#window.commandCenter#`",
+                "`#chat.viewSessions.enabled#`"
+            )),
+            default: "compact",
+            tags: ["experimental"]
+        },
+        [ChatConfiguration.UnifiedAgentsBar]: {
+            type: "boolean",
+            markdownDescription: ( localize(
+                5819,
+                "Replaces the command center search box with a unified chat and search widget."
+            )),
+            default: false,
+            tags: ["experimental"]
+        },
+        [ChatConfiguration.AgentSessionProjectionEnabled]: {
+            type: "boolean",
+            markdownDescription: ( localize(
+                5820,
+                "Controls whether Agent Session Projection mode is enabled for reviewing agent sessions in a focused workspace."
+            )),
+            default: false,
+            tags: ["experimental"]
+        },
+        "chat.implicitContext.enabled": {
+            type: "object",
+            description: ( localize(
+                5821,
+                "Enables automatically using the active editor as chat context for specified chat locations."
+            )),
+            additionalProperties: {
+                type: "string",
+                enum: ["never", "first", "always"],
+                description: ( localize(5822, "The value for the implicit context.")),
+                enumDescriptions: [( localize(5823, "Implicit context is never enabled.")), ( localize(5824, "Implicit context is enabled for the first interaction.")), ( localize(5825, "Implicit context is always enabled."))]
+            },
+            default: {
+                "panel": "always"
+            },
+            tags: ["experimental"],
+            experiment: {
+                mode: "startup"
+            },
+            agentsWindow: {
+                default: {
+                    "panel": "never"
+                }
+            }
+        },
+        "chat.implicitContext.suggestedContext": {
+            type: "boolean",
+            markdownDescription: ( localize(
+                5826,
+                "Controls whether the new implicit context flow is shown. In Ask and Edit modes, the context will automatically be included. When using an agent, context will be suggested as an attachment. Selections are always included as context."
+            )),
+            default: true,
+            agentsWindow: {
+                default: false
+            }
+        },
+        "chat.editing.autoAcceptDelay": {
+            type: "number",
+            markdownDescription: ( localize(
+                5827,
+                "Delay after which changes made by chat are automatically accepted. Values are in seconds, `0` means disabled and `100` seconds is the maximum."
+            )),
+            default: 0,
+            minimum: 0,
+            maximum: 100
+        },
+        "chat.editing.confirmEditRequestRemoval": {
+            type: "boolean",
+            scope: ConfigurationScope.APPLICATION,
+            markdownDescription: ( localize(
+                5828,
+                "Whether to show a confirmation before removing a request and its associated edits."
+            )),
+            default: true
+        },
+        "chat.editing.confirmEditRequestRetry": {
+            type: "boolean",
+            scope: ConfigurationScope.APPLICATION,
+            markdownDescription: ( localize(
+                5829,
+                "Whether to show a confirmation before retrying a request and its associated edits."
+            )),
+            default: true
+        },
+        "chat.editing.explainChanges.enabled": {
+            type: "boolean",
+            markdownDescription: ( localize(
+                5830,
+                "Controls whether the Explain button in the Chat panel and the Explain Changes context menu in the SCM view are shown. This is an experimental feature."
+            )),
+            default: false,
+            tags: ["experimental"],
+            experiment: {
+                mode: "auto"
+            }
+        },
+        [ChatConfiguration.RevealNextChangeOnResolve]: {
+            type: "boolean",
+            markdownDescription: ( localize(
+                5831,
+                "Controls whether the editor automatically reveals the next change after keeping or undoing a chat edit."
+            )),
+            default: true
+        },
+        "chat.tips.enabled": {
+            type: "boolean",
+            scope: ConfigurationScope.APPLICATION,
+            description: ( localize(
+                5832,
+                "Controls whether tips are shown above user messages in chat. New tips are added frequently, so this is a helpful way to stay up to date with the latest features."
+            )),
+            default: true
+        },
+        "chat.upvoteAnimation": {
+            type: "string",
+            enum: ["off", "confetti", "floatingThumbs", "pulseWave", "radiantLines"],
+            enumDescriptions: [( localize(5833, "No animation is shown.")), ( localize(5834, "Shows a confetti burst animation around the thumbs up button.")), ( localize(5835, "Shows floating thumbs up icons rising from the button.")), ( localize(5836, "Shows expanding pulse rings from the button.")), ( localize(5837, "Shows radiant lines emanating from the button."))],
+            description: ( localize(
+                5838,
+                "Controls whether an animation is shown when clicking the thumbs up button on a chat response."
+            )),
+            default: "floatingThumbs"
+        },
+        "chat.experimental.detectParticipant.enabled": {
+            type: "boolean",
+            deprecationMessage: ( localize(
+                5839,
+                "This setting is deprecated. Please use `chat.detectParticipant.enabled` instead."
+            )),
+            description: ( localize(5840, "Enables chat participant autodetection for panel chat.")),
+            default: null
+        },
+        [ChatConfiguration.IncrementalRendering]: {
+            type: "boolean",
+            description: ( localize(
+                5841,
+                "Enables incremental rendering with optional block-level animation when streaming chat responses."
+            )),
+            default: false,
+            tags: ["experimental"]
+        },
+        [ChatConfiguration.IncrementalRenderingStyle]: {
+            type: "string",
+            enum: ["none", "fade", "rise", "blur", "scale", "slide", "reveal"],
+            enumDescriptions: [( localize(5842, "No animation. Content appears instantly.")), ( localize(5843, "Simple opacity fade from 0 to 1.")), ( localize(5844, "Content fades in while rising upward.")), ( localize(5845, "Content fades in from a blurred state.")), ( localize(5846, "Content scales up from slightly smaller.")), ( localize(5847, "Content slides in from the left.")), ( localize(5848, "Content reveals top-to-bottom with a soft gradient edge."))],
+            description: ( localize(5849, "Controls the animation style for incremental rendering.")),
+            default: "fade",
+            tags: ["experimental"]
+        },
+        [ChatConfiguration.IncrementalRenderingBuffering]: {
+            type: "string",
+            enum: ["off", "word", "paragraph"],
+            enumDescriptions: [( localize(5850, "Renders content immediately as tokens arrive.")), ( localize(5851, "Reveals content word by word.")), ( localize(5852, "Buffers content until a paragraph break before rendering."))],
+            description: ( localize(
+                5853,
+                "Controls how content is buffered before rendering during incremental rendering. Lower buffering levels render faster but may show incomplete sentences or partially formed markdown."
+            )),
+            default: "word",
+            tags: ["experimental"]
+        },
+        "chat.detectParticipant.enabled": {
+            type: "boolean",
+            description: ( localize(5854, "Enables chat participant autodetection for panel chat.")),
+            default: true
+        },
+        [ChatConfiguration.InlineReferencesStyle]: {
+            type: "string",
+            enum: ["box", "link"],
+            enumDescriptions: [( localize(5855, "Display file and symbol references as boxed widgets with icons.")), ( localize(
+                5856,
+                "Display file and symbol references as simple blue links without icons."
+            ))],
+            description: ( localize(
+                5857,
+                "Controls how file and symbol references are displayed in chat messages."
+            )),
+            default: "box"
+        },
+        [ChatConfiguration.EditorAssociations]: {
+            type: "object",
+            markdownDescription: ( localize(
+                5858,
+                "Configure [glob patterns](https://aka.ms/vscode-glob-patterns) to editors for opening files from chat (for example `\"*.md\": \"vscode.markdown.preview.editor\"`)."
+            )),
+            additionalProperties: {
+                type: "string"
+            },
+            default: {}
+        },
+        [ChatConfiguration.NotifyWindowOnConfirmation]: {
+            type: "string",
+            enum: ["off", "windowNotFocused", "always"],
+            enumDescriptions: [( localize(5859, "Never show OS notifications for confirmations.")), ( localize(
+                5860,
+                "Show OS notifications for confirmations when the window is not focused."
+            )), ( localize(
+                5861,
+                "Always show OS notifications for confirmations, even when the window is focused."
+            ))],
+            description: ( localize(
+                5862,
+                "Controls whether a chat session should present the user with an OS notification when a confirmation or question needs input. This includes a window badge as well as notification toast."
+            )),
+            default: "windowNotFocused"
+        },
+        [ChatConfiguration.AutoReply]: {
+            default: false,
+            markdownDescription: ( localize(
+                5863,
+                "Automatically skip question carousels by telling the agent that the user is not available and to use its best judgment. This is an advanced setting and can lead to unintended choices or actions based on incomplete context."
+            )),
+            type: "boolean",
+            scope: ConfigurationScope.APPLICATION_MACHINE,
+            tags: ["experimental", "advanced"]
+        },
+        [ChatConfiguration.AutopilotEnabled]: {
+            type: "boolean",
+            markdownDescription: ( localize(
+                5864,
+                "Controls whether the Autopilot mode is available in the permissions picker. When enabled, Autopilot auto-approves all tool calls and continues until the task is done."
+            )),
+            default: true,
+            tags: ["experimental"]
+        },
+        [ChatConfiguration.PlanReviewInlineEditorEnabled]: {
+            type: "boolean",
+            markdownDescription: ( localize(
+                5865,
+                "When enabled, the plan review widget mounts an editor inline, as opposed to in a separate editor tab."
+            )),
+            default: true
+        },
+        [ChatConfiguration.DefaultPermissionLevel]: {
+            type: "string",
+            enum: [
+                ChatPermissionLevel.Default,
+                ChatPermissionLevel.AutoApprove,
+                ChatPermissionLevel.Autopilot
+            ],
+            enumItemLabels: [( localize(5866, "Default Approvals")), ( localize(5867, "Bypass Approvals")), ( localize(5868, "Autopilot (Preview)"))],
+            enumDescriptions: [( localize(5869, "Start new chat sessions with Default Approvals.")), ( localize(5870, "Start new chat sessions in Bypass Approvals mode.")), ( localize(5871, "Start new chat sessions in Autopilot mode."))],
+            description: ( localize(
+                5872,
+                "Controls the default permissions picker mode for new chat sessions. You can still change the permission mode per session, and each session remembers the permission mode that was used. If enterprise policy disables auto approval, new sessions use Default Approvals."
+            )),
+            default: ChatPermissionLevel.Default,
+            tags: ["experimental"]
+        },
+        [ChatConfiguration.GlobalAutoApprove]: {
+            default: false,
+            markdownDescription: globalAutoApproveDescription.value,
+            type: "boolean",
+            scope: ConfigurationScope.APPLICATION_MACHINE,
+            tags: ["experimental"],
+            policy: {
+                name: "ChatToolsAutoApprove",
+                category: PolicyCategory.InteractiveSession,
+                minimumVersion: "1.99",
+                value: policyData => policyData.chat_preview_features_enabled === false ? false : undefined,
+                localization: {
+                    description: {
+                        key: "autoApprove3.description",
+                        value: ( localize(
+                            5873,
+                            "Global auto approve also known as \"YOLO mode\" disables manual approval completely for all tools in all workspaces, allowing the agent to act fully autonomously. This is extremely dangerous and is *never* recommended, even containerized environments like Codespaces and Dev Containers have user keys forwarded into the container that could be compromised.\n\nThis feature disables critical security protections and makes it much easier for an attacker to compromise the machine.\n\nNote: This setting only controls tool approval and does not prevent the agent from asking questions. To automatically answer agent questions, use the `#chat.autoReply#` setting."
+                        ))
+                    }
+                }
+            }
+        },
+        [ChatConfiguration.SessionSyncEnabled]: {
+            default: false,
+            markdownDescription: ( localize(
+                5874,
+                "Enable session sync to GitHub.com. When enabled, Copilot session data is synced to your GitHub account for cross-device access and richer insights. Requires `#github.copilot.chat.localIndex.enabled#` to also be enabled."
+            )),
+            type: "boolean",
+            tags: ["experimental", "advanced"],
+            experiment: {
+                mode: "auto"
+            },
+            policy: {
+                name: "CopilotSessionSync",
+                category: PolicyCategory.InteractiveSession,
+                minimumVersion: "1.121",
+                value: policyData => policyData.cloud_session_storage_enabled === false ? false : undefined,
+                localization: {
+                    description: {
+                        key: "chat.sessionSync.enabled.policy",
+                        value: ( localize(
+                            5875,
+                            "Enable session sync to GitHub.com for cross-device Copilot session history. When disabled by organization policy, session data is kept local only."
+                        ))
+                    }
+                }
+            }
+        },
+        [ChatConfiguration.SessionSyncExcludeRepositories]: {
+            type: "array",
+            items: {
+                type: "string"
+            },
+            default: [],
+            markdownDescription: ( localize(
+                5876,
+                "Repository patterns to exclude from session sync. Use exact `owner/repo` names or glob patterns like `my-org/*`. Sessions from matching repositories will only be stored locally."
+            )),
+            tags: ["experimental", "advanced"]
+        },
+        [ChatConfiguration.AutoApproveEdits]: {
+            default: {
+                "**/*": true,
+                "**/.vscode/*.json": false,
+                "**/.git/**": false,
+                "**/{package.json,server.xml,build.rs,web.config,.gitattributes,.env}": false,
+                "**/*.{code-workspace,csproj,fsproj,vbproj,vcxproj,proj,targets,props}": false,
+                "**/*.lock": false,
+                "**/*-lock.{yaml,json}": false
+            },
+            markdownDescription: ( localize(
+                5877,
+                "Controls whether edits made by the agent are automatically approved. The default is to approve all edits except those made to certain files which have the potential to cause immediate unintended side-effects, such as `**/.vscode/*.json`.\n\nSet to `true` to automatically approve edits to matching files, `false` to always require explicit approval. The last pattern matching a given file will determine whether the edit is automatically approved."
+            )),
+            type: "object",
+            additionalProperties: {
+                type: "boolean"
+            }
+        },
+        [ChatConfiguration.AutoApprovedUrls]: {
+            default: {
+                "https://code.visualstudio.com": true,
+                "https://github.com/microsoft/vscode/wiki/*": true
+            },
+            markdownDescription: ( localize(
+                5878,
+                "Controls which URLs are automatically approved when requested by chat tools. Keys are URL patterns and values can be `true` to approve both requests and responses, `false` to deny, or an object with `approveRequest` and `approveResponse` properties for granular control.\n\nExamples:\n- `\"https://example.com\": true` - Approve all requests to example.com\n- `\"https://*.example.com\": true` - Approve all requests to any subdomain of example.com\n- `\"https://example.com/api/*\": { \"approveRequest\": true, \"approveResponse\": false }` - Approve requests but not responses for example.com/api paths"
+            )),
+            type: "object",
+            additionalProperties: {
+                oneOf: [{
+                    type: "boolean"
+                }, {
+                    type: "object",
+                    properties: {
+                        approveRequest: {
+                            type: "boolean"
+                        },
+                        approveResponse: {
+                            type: "boolean"
+                        }
+                    }
+                }]
+            }
+        },
+        [ChatConfiguration.EligibleForAutoApproval]: {
+            default: {},
+            markdownDescription: ( localize(
+                5879,
+                "Controls which tools are eligible for automatic approval. Tools set to 'false' will always present a confirmation and will never offer the option to auto-approve. The default behavior (or setting a tool to 'true') may result in the tool offering auto-approval options."
+            )),
+            type: "object",
+            propertyNames: {
+                enum: toolReferenceNameEnumValues,
+                enumDescriptions: toolReferenceNameEnumDescriptions
+            },
+            additionalProperties: {
+                type: "boolean"
+            },
+            examples: [{
+                "fetch": false,
+                "runTask": false
+            }],
+            policy: {
+                name: "ChatToolsEligibleForAutoApproval",
+                category: PolicyCategory.InteractiveSession,
+                minimumVersion: "1.107",
+                localization: {
+                    description: {
+                        key: "chat.tools.eligibleForAutoApproval",
+                        value: ( localize(
+                            5879,
+                            "Controls which tools are eligible for automatic approval. Tools set to 'false' will always present a confirmation and will never offer the option to auto-approve. The default behavior (or setting a tool to 'true') may result in the tool offering auto-approval options."
+                        ))
+                    }
+                }
+            }
+        },
+        "chat.sendElementsToChat.attachImages": {
+            default: true,
+            markdownDescription: ( localize(
+                5880,
+                "Controls whether a screenshot of the selected element will be added to the chat."
+            )),
+            type: "boolean",
+            tags: ["experimental"]
+        },
+        [ChatConfiguration.ArtifactsEnabled]: {
+            default: false,
+            description: ( localize(5881, "Controls whether the artifacts view is available in chat.")),
+            type: "boolean",
+            tags: ["experimental"]
+        },
+        [ChatConfiguration.ArtifactsRulesByMimeType]: {
+            default: {
+                "image/*": {
+                    groupName: "Screenshots",
+                    onlyShowGroup: true
+                }
+            },
+            description: ( localize(
+                5882,
+                "Rules for extracting artifacts from tool results by MIME type. Maps MIME type patterns (e.g. 'image/*') to group configuration."
+            )),
+            type: "object",
+            additionalProperties: {
+                type: "object",
+                properties: {
+                    groupName: {
+                        type: "string",
+                        description: ( localize(5883, "Display name for the artifact group."))
+                    },
+                    onlyShowGroup: {
+                        type: "boolean",
+                        description: ( localize(5884, "When true, show only the group header instead of individual items."))
+                    }
+                },
+                required: ["groupName"]
+            },
+            tags: ["experimental"]
+        },
+        [ChatConfiguration.ArtifactsRulesByFilePath]: {
+            default: {
+                "**/*plan*.md": {
+                    groupName: "Plans"
+                }
+            },
+            description: ( localize(
+                5885,
+                "Rules for extracting artifacts from written files by file path pattern. Maps glob patterns to group configuration."
+            )),
+            type: "object",
+            additionalProperties: {
+                type: "object",
+                properties: {
+                    groupName: {
+                        type: "string",
+                        description: ( localize(5886, "Display name for the artifact group."))
+                    },
+                    onlyShowGroup: {
+                        type: "boolean",
+                        description: ( localize(5887, "When true, show only the group header instead of individual items."))
+                    }
+                },
+                required: ["groupName"]
+            },
+            tags: ["experimental"]
+        },
+        [ChatConfiguration.ArtifactsRulesByMemoryFilePath]: {
+            default: {
+                "**/*plan*.md": {
+                    groupName: "Plans"
+                }
+            },
+            description: ( localize(
+                5888,
+                "Rules for extracting artifacts from memory tool calls by memory file path pattern. Maps glob patterns to group configuration."
+            )),
+            type: "object",
+            additionalProperties: {
+                type: "object",
+                properties: {
+                    groupName: {
+                        type: "string",
+                        description: ( localize(5889, "Display name for the artifact group."))
+                    },
+                    onlyShowGroup: {
+                        type: "boolean",
+                        description: ( localize(5890, "When true, show only the group header instead of individual items."))
+                    }
+                },
+                required: ["groupName"]
+            },
+            tags: ["experimental"]
+        },
+        "chat.undoRequests.restoreInput": {
+            default: true,
+            markdownDescription: ( localize(
+                5891,
+                "Controls whether the input of the chat should be restored when an undo request is made. The input will be filled with the text of the request that was restored."
+            )),
+            type: "boolean"
+        },
+        "chat.editRequests": {
+            markdownDescription: ( localize(
+                5892,
+                "Enables editing of requests in the chat. This allows you to change the request content and resubmit it to the model."
+            )),
+            type: "string",
+            enum: ["inline", "hover", "input", "none"],
+            default: "inline"
+        },
+        [ChatConfiguration.ChatViewSessionsEnabled]: {
+            type: "boolean",
+            default: true,
+            description: ( localize(
+                5893,
+                "Show chat agent sessions when chat is empty or to the side when chat view is wide enough."
+            )),
+            agentsWindow: {
+                default: false
+            }
+        },
+        [ChatConfiguration.ChatViewSessionsOrientation]: {
+            type: "string",
+            enum: ["stacked", "sideBySide"],
+            enumDescriptions: [( localize(
+                5894,
+                "Display chat sessions vertically stacked above the chat input unless a chat session is visible."
+            )), ( localize(
+                5895,
+                "Display chat sessions side by side if space is sufficient, otherwise fallback to stacked above the chat input unless a chat session is visible."
+            ))],
+            default: "sideBySide",
+            description: ( localize(
+                5896,
+                "Controls the orientation of the chat agent sessions view when it is shown alongside the chat."
+            ))
+        },
+        [ChatConfiguration.ChatViewProgressBadgeEnabled]: {
+            type: "boolean",
+            default: false,
+            description: ( localize(
+                5897,
+                "Show a progress badge on the chat view when an agent session is in progress that is opened in that view."
+            ))
+        },
+        [ChatConfiguration.ChatContextUsageEnabled]: {
+            type: "boolean",
+            default: true,
+            description: ( localize(5898, "Show the context window usage indicator in the chat input."))
+        },
+        [ChatConfiguration.ChatPersistentProgressEnabled]: {
+            type: "boolean",
+            default: product.quality !== "stable",
+            description: ( localize(5899, "Always show progress in chat."))
+        },
+        [ChatConfiguration.ProgressBorder]: {
+            type: "boolean",
+            default: true,
+            markdownDescription: ( localize(
+                5900,
+                "Show an animated gradient border around the chat input while the agent is working or thinking. When enabled and reduced motion is not enabled, this overrides {0} to be off. Has no effect when reduced motion is enabled.",
+                "`#chat.persistentProgress.enabled#`"
+            ))
+        },
+        [ChatConfiguration.NotifyWindowOnResponseReceived]: {
+            type: "string",
+            enum: ["off", "windowNotFocused", "always"],
+            enumDescriptions: [( localize(5901, "Never show OS notifications for responses.")), ( localize(
+                5902,
+                "Show OS notifications for responses when the window is not focused."
+            )), ( localize(
+                5903,
+                "Always show OS notifications for responses, even when the window is focused."
+            ))],
+            default: "windowNotFocused",
+            description: ( localize(
+                5904,
+                "Controls whether a chat session should present the user with an OS notification when a response is received. This includes a window badge as well as notification toast."
+            ))
+        },
+        "chat.checkpoints.enabled": {
+            type: "boolean",
+            default: true,
+            description: ( localize(
+                5905,
+                "Enables checkpoints in chat. Checkpoints allow you to restore the chat to a previous state."
+            ))
+        },
+        "chat.checkpoints.showFileChanges": {
+            type: "boolean",
+            description: ( localize(5906, "Controls whether to show chat checkpoint file changes.")),
+            default: false
+        },
+        [mcpAccessConfig]: {
+            type: "string",
+            description: ( localize(5907, "Controls access to installed Model Context Protocol servers.")),
+            enum: [McpAccessValue.None, McpAccessValue.Registry, McpAccessValue.All],
+            enumDescriptions: [( localize(5908, "No access to MCP servers.")), ( localize(
+                5909,
+                "Allows access to MCP servers installed from the registry that VS Code is connected to."
+            )), ( localize(5910, "Allow access to any installed MCP server."))],
+            default: McpAccessValue.All,
+            policy: {
+                name: "ChatMCP",
+                category: PolicyCategory.InteractiveSession,
+                minimumVersion: "1.99",
+                value: policyData => {
+                    if (policyData.mcp === false) {
+                        return McpAccessValue.None;
+                    }
+                    if (policyData.mcpAccess === "registry_only") {
+                        return McpAccessValue.Registry;
+                    }
+                    return undefined;
+                },
+                localization: {
+                    description: {
+                        key: "chat.mcp.access",
+                        value: ( localize(5907, "Controls access to installed Model Context Protocol servers."))
+                    },
+                    enumDescriptions: [{
+                        key: "chat.mcp.access.none",
+                        value: ( localize(5908, "No access to MCP servers."))
+                    }, {
+                        key: "chat.mcp.access.registry",
+                        value: ( localize(
+                            5909,
+                            "Allows access to MCP servers installed from the registry that VS Code is connected to."
+                        ))
+                    }, {
+                        key: "chat.mcp.access.any",
+                        value: ( localize(5910, "Allow access to any installed MCP server."))
+                    }]
+                }
+            }
+        },
+        [mcpAutoStartConfig]: {
+            type: "string",
+            description: ( localize(
+                5911,
+                "Controls whether MCP servers should be automatically started when the chat messages are submitted."
+            )),
+            default: McpAutoStartValue.NewAndOutdated,
+            enum: [
+                McpAutoStartValue.Never,
+                McpAutoStartValue.OnlyNew,
+                McpAutoStartValue.NewAndOutdated
+            ],
+            enumDescriptions: [( localize(5912, "Never automatically start MCP servers.")), ( localize(5913, "Only automatically start new MCP servers that have never been run.")), ( localize(
+                5914,
+                "Automatically start new and outdated MCP servers that are not yet running."
+            ))],
+            tags: ["experimental"]
+        },
+        [mcpAppsEnabledConfig]: {
+            type: "boolean",
+            description: ( localize(
+                5915,
+                "Controls whether MCP servers can provide custom UI for tool invocations."
+            )),
+            default: true,
+            tags: ["experimental"]
+        },
+        [mcpServerCollisionBehaviorSection]: {
+            type: "string",
+            description: ( localize(
+                5916,
+                "Controls behavior when multiple MCP servers are discovered with the same name. 'disable' disables lower-priority duplicates. 'suffix' appends numeric suffixes to disambiguate."
+            )),
+            enum: [McpCollisionBehavior.Disable, McpCollisionBehavior.Suffix],
+            enumDescriptions: [( localize(5917, "Disable lower-priority servers with duplicate names.")), ( localize(5918, "Append numeric suffixes to servers with duplicate names."))],
+            default: McpCollisionBehavior.Disable
+        },
+        [mcpServerSamplingSection]: {
+            type: "object",
+            description: ( localize(
+                5919,
+                "Configures which models are exposed to MCP servers for sampling (making model requests in the background). This setting can be edited in a graphical way under the `{0}` command.",
+                "MCP: " + ( localize(5920, "List Servers"))
+            )),
+            scope: ConfigurationScope.RESOURCE,
+            additionalProperties: {
+                type: "object",
+                properties: {
+                    allowedDuringChat: {
+                        type: "boolean",
+                        description: ( localize(
+                            5921,
+                            "Whether this server is allowed to make sampling requests during its tool calls in a chat session."
+                        )),
+                        default: true
+                    },
+                    allowedOutsideChat: {
+                        type: "boolean",
+                        description: ( localize(
+                            5922,
+                            "Whether this server is allowed to make sampling requests outside of a chat session."
+                        )),
+                        default: false
+                    },
+                    allowedModels: {
+                        type: "array",
+                        items: {
+                            type: "string",
+                            description: ( localize(5923, "A model the MCP server has access to."))
+                        }
+                    }
+                }
+            }
+        },
+        [AssistedTypes[AddConfigurationType.NuGetPackage].enabledConfigKey]: {
+            type: "boolean",
+            description: ( localize(
+                5924,
+                "Enables NuGet packages for AI-assisted MCP server installation. Used to install MCP servers by name from the central registry for .NET packages (NuGet.org)."
+            )),
+            default: false,
+            tags: ["experimental"],
+            experiment: {
+                mode: "startup"
+            }
+        },
+        [ChatConfiguration.ExtensionToolsEnabled]: {
+            type: "boolean",
+            description: ( localize(5925, "Enable using tools contributed by third-party extensions.")),
+            default: true,
+            policy: {
+                name: "ChatAgentExtensionTools",
+                category: PolicyCategory.InteractiveSession,
+                minimumVersion: "1.99",
+                localization: {
+                    description: {
+                        key: "chat.extensionToolsEnabled",
+                        value: ( localize(5925, "Enable using tools contributed by third-party extensions."))
+                    }
+                }
+            }
+        },
+        [ChatConfiguration.PluginsEnabled]: {
+            type: "boolean",
+            description: ( localize(5926, "Enable agent plugin integration in chat.")),
+            default: true,
+            tags: ["preview"],
+            policy: {
+                name: "ChatPluginsEnabled",
+                category: PolicyCategory.InteractiveSession,
+                minimumVersion: "1.116",
+                localization: {
+                    description: {
+                        key: "chat.plugins.enabled",
+                        value: ( localize(5926, "Enable agent plugin integration in chat."))
+                    }
+                }
+            }
+        },
+        [ChatConfiguration.PluginLocations]: {
+            type: "object",
+            additionalProperties: {
+                type: "boolean"
+            },
+            restricted: true,
+            markdownDescription: ( localize(
+                5927,
+                "Plugin directories to discover. Each key is a path that points directly to a plugin folder, and the value enables (`true`) or disables (`false`) it. Paths can be absolute, relative to the workspace root, or start with `~/` for the user's home directory."
+            )),
+            scope: ConfigurationScope.MACHINE,
+            tags: ["experimental"]
+        },
+        [ChatConfiguration.PluginMarketplaces]: {
+            type: "array",
+            items: {
+                type: "string"
+            },
+            markdownDescription: ( localize(
+                5928,
+                "Plugin marketplaces to query. Entries may be GitHub shorthand (`owner/repo`), direct Git repository URIs (`https://...git`, `ssh://...git`, or `git@host:path.git`), or local repository URIs (`file:///...`). Equivalent GitHub shorthand and URI entries are deduplicated."
+            )),
+            default: ["github/copilot-plugins", "github/awesome-copilot"],
+            scope: ConfigurationScope.APPLICATION,
+            tags: ["experimental"]
+        },
+        [ChatConfiguration.AgentEnabled]: {
+            type: "boolean",
+            description: ( localize(
+                5929,
+                "When enabled, agent mode can be activated from chat and tools in agentic contexts with side effects can be used."
+            )),
+            default: true,
+            order: 1,
+            policy: {
+                name: "ChatAgentMode",
+                category: PolicyCategory.InteractiveSession,
+                minimumVersion: "1.99",
+                value: policyData => policyData.chat_agent_enabled === false ? false : undefined,
+                localization: {
+                    description: {
+                        key: "chat.agent.enabled.description",
+                        value: ( localize(
+                            5929,
+                            "When enabled, agent mode can be activated from chat and tools in agentic contexts with side effects can be used."
+                        ))
+                    }
+                }
+            }
+        },
+        [AgentNetworkDomainSettingId.NetworkFilter]: {
+            markdownDescription: ( localize(
+                5930,
+                "When enabled, network access by agent tools (fetch tool, integrated browser) is restricted according to {0} and {1}. Domain filtering is also applied to those tools when {2} is enabled.",
+                `\`#${AgentNetworkDomainSettingId.AllowedNetworkDomains}#\``,
+                `\`#${AgentNetworkDomainSettingId.DeniedNetworkDomains}#\``,
+                `\`#${AgentSandboxSettingId.AgentSandboxEnabled}#\``
+            )),
+            type: "boolean",
+            default: false,
+            restricted: true,
+            policy: {
+                name: "ChatAgentNetworkFilter",
+                category: PolicyCategory.InteractiveSession,
+                minimumVersion: "1.116",
+                localization: {
+                    description: {
+                        key: "chat.agent.networkFilter",
+                        value: ( localize(
+                            5930,
+                            "When enabled, network access by agent tools (fetch tool, integrated browser) is restricted according to {0} and {1}. Domain filtering is also applied to those tools when {2} is enabled.",
+                            `\`#${AgentNetworkDomainSettingId.AllowedNetworkDomains}#\``,
+                            `\`#${AgentNetworkDomainSettingId.DeniedNetworkDomains}#\``,
+                            `\`#${AgentSandboxSettingId.AgentSandboxEnabled}#\``
+                        ))
+                    }
+                }
+            }
+        },
+        [AgentNetworkDomainSettingId.AllowedNetworkDomains]: {
+            markdownDescription: ( localize(
+                5931,
+                "Allowed domains for network access by agent tools (fetch tool, integrated browser). Applies when {0} or {1} is enabled. When {1} is set to {2}, all domains are allowed. Supports wildcards like {3}. When both allowed and denied lists are empty, all domains are blocked. Denied domains (see {4}) take precedence.",
+                `\`#${AgentNetworkDomainSettingId.NetworkFilter}#\``,
+                `\`#${AgentSandboxSettingId.AgentSandboxEnabled}#\``,
+                `\`${AgentSandboxEnabledValue.AllowNetwork}\``,
+                "`*.example.com`",
+                `\`#${AgentNetworkDomainSettingId.DeniedNetworkDomains}#\``
+            )),
+            type: "array",
+            items: {
+                type: "string"
+            },
+            default: [],
+            restricted: true,
+            policy: {
+                name: "ChatAgentAllowedNetworkDomains",
+                category: PolicyCategory.InteractiveSession,
+                minimumVersion: "1.116",
+                localization: {
+                    description: {
+                        key: "chat.agent.allowedNetworkDomains",
+                        value: ( localize(
+                            5931,
+                            "Allowed domains for network access by agent tools (fetch tool, integrated browser). Applies when {0} or {1} is enabled. When {1} is set to {2}, all domains are allowed. Supports wildcards like {3}. When both allowed and denied lists are empty, all domains are blocked. Denied domains (see {4}) take precedence.",
+                            `\`#${AgentNetworkDomainSettingId.NetworkFilter}#\``,
+                            `\`#${AgentSandboxSettingId.AgentSandboxEnabled}#\``,
+                            `\`${AgentSandboxEnabledValue.AllowNetwork}\``,
+                            "`*.example.com`",
+                            `\`#${AgentNetworkDomainSettingId.DeniedNetworkDomains}#\``
+                        ))
+                    }
+                }
+            }
+        },
+        [AgentNetworkDomainSettingId.DeniedNetworkDomains]: {
+            markdownDescription: ( localize(
+                5932,
+                "Denied domains for network access by agent tools (fetch tool, integrated browser). Applies when {0} or {1} is enabled. This does not apply when {1} is set to {2}. Takes precedence over {3}. Supports wildcards like {4}.",
+                `\`#${AgentNetworkDomainSettingId.NetworkFilter}#\``,
+                `\`#${AgentSandboxSettingId.AgentSandboxEnabled}#\``,
+                `\`${AgentSandboxEnabledValue.AllowNetwork}\``,
+                `\`#${AgentNetworkDomainSettingId.AllowedNetworkDomains}#\``,
+                "`*.example.com`"
+            )),
+            type: "array",
+            items: {
+                type: "string"
+            },
+            default: [],
+            restricted: true,
+            policy: {
+                name: "ChatAgentDeniedNetworkDomains",
+                category: PolicyCategory.InteractiveSession,
+                minimumVersion: "1.116",
+                localization: {
+                    description: {
+                        key: "chat.agent.deniedNetworkDomains",
+                        value: ( localize(
+                            5932,
+                            "Denied domains for network access by agent tools (fetch tool, integrated browser). Applies when {0} or {1} is enabled. This does not apply when {1} is set to {2}. Takes precedence over {3}. Supports wildcards like {4}.",
+                            `\`#${AgentNetworkDomainSettingId.NetworkFilter}#\``,
+                            `\`#${AgentSandboxSettingId.AgentSandboxEnabled}#\``,
+                            `\`${AgentSandboxEnabledValue.AllowNetwork}\``,
+                            `\`#${AgentNetworkDomainSettingId.AllowedNetworkDomains}#\``,
+                            "`*.example.com`"
+                        ))
+                    }
+                }
+            }
+        },
+        [AgentNetworkDomainSettingId.DeprecatedOldAllowedNetworkDomains]: {
+            type: "array",
+            items: {
+                type: "string"
+            },
+            deprecated: true,
+            markdownDeprecationMessage: ( localize(
+                5933,
+                "Use {0} instead",
+                `\`#${AgentNetworkDomainSettingId.AllowedNetworkDomains}#\``
+            ))
+        },
+        [AgentNetworkDomainSettingId.DeprecatedOldDeniedNetworkDomains]: {
+            type: "array",
+            items: {
+                type: "string"
+            },
+            deprecated: true,
+            markdownDeprecationMessage: ( localize(
+                5934,
+                "Use {0} instead",
+                `\`#${AgentNetworkDomainSettingId.DeniedNetworkDomains}#\``
+            ))
+        },
+        [AgentNetworkDomainSettingId.DeprecatedSandboxAllowedNetworkDomains]: {
+            type: "array",
+            items: {
+                type: "string"
+            },
+            deprecated: true,
+            markdownDeprecationMessage: ( localize(
+                5935,
+                "Use {0} instead",
+                `\`#${AgentNetworkDomainSettingId.AllowedNetworkDomains}#\``
+            ))
+        },
+        [AgentNetworkDomainSettingId.DeprecatedSandboxDeniedNetworkDomains]: {
+            type: "array",
+            items: {
+                type: "string"
+            },
+            deprecated: true,
+            markdownDeprecationMessage: ( localize(
+                5936,
+                "Use {0} instead",
+                `\`#${AgentNetworkDomainSettingId.DeniedNetworkDomains}#\``
+            ))
+        },
+        [ChatConfiguration.DefaultNewSessionMode]: {
+            type: "string",
+            description: ( localize(
+                5937,
+                "The default mode for new chat sessions. When empty, the chat view's default mode is used."
+            )),
+            default: ""
+        },
+        [AgentHostEnabledSettingId]: {
+            type: "boolean",
+            description: ( localize(5938, "When enabled, some agents run in a separate agent host process.")),
+            default: false,
+            tags: ["experimental", "advanced"],
+            included: product.quality !== "stable"
+        },
+        [AgentHostClaudeAgentSdkPathSettingId]: {
+            type: "string",
+            description: ( localize(
+                5939,
+                "Experimental, for local testing only. Absolute path to a locally-installed `@anthropic-ai/claude-agent-sdk` package. When set, the Claude agent provider is registered inside the agent host and the SDK is loaded from this path. Requires `#chat.agentHost.enabled#`. The agent host process must be restarted for changes to take effect. This setting will be removed once the SDK is delivered through the Extension Marketplace."
+            )),
+            default: "",
+            tags: ["experimental", "advanced"],
+            included: product.quality !== "stable"
+        },
+        [AgentHostIpcLoggingSettingId]: {
+            type: "boolean",
+            description: ( localize(
+                5940,
+                "When enabled, logs all IPC traffic for each agent host to a dedicated output channel."
+            )),
+            default: product.quality !== "stable",
+            tags: ["experimental", "advanced"],
+            included: product.quality !== "stable"
+        },
+        [AgentHostAhpJsonlLoggingSettingId]: {
+            type: "boolean",
+            description: ( localize(
+                5941,
+                "When enabled, logs all AHP transport messages for agent host connections to JSONL files under the window's log directory."
+            )),
+            default: product.quality !== "stable",
+            tags: ["experimental", "advanced"],
+            included: product.quality !== "stable"
+        },
+        [AgentHostCustomTerminalToolEnabledSettingId]: {
+            type: "boolean",
+            description: ( localize(
+                5942,
+                "When enabled, Copilot SDK sessions use the Agent Host terminal tool override instead of the SDK's default terminal behavior."
+            )),
+            default: true,
+            tags: ["experimental", "advanced"],
+            included: product.quality !== "stable"
+        },
+        [AgentHostOTelEnabledSettingId]: {
+            type: "boolean",
+            description: ( localize(
+                5943,
+                "When enabled, the agent host emits OpenTelemetry traces from the Copilot SDK. Requires `#chat.agentHost.enabled#`. Either configure `#chat.agentHost.otel.otlpEndpoint#` to ship traces to an external collector or enable `#chat.agentHost.otel.dbSpanExporter.enabled#` to capture them locally."
+            )),
+            default: false,
+            tags: ["experimental", "advanced"],
+            included: product.quality !== "stable"
+        },
+        [AgentHostOTelExporterTypeSettingId]: {
+            type: "string",
+            enum: ["otlp-http", "otlp-grpc", "console", "file"],
+            description: ( localize(
+                5944,
+                "Exporter backend used by the Copilot SDK when `#chat.agentHost.otel.enabled#` is on. `otlp-grpc` is downgraded to `otlp-http` transparently in the CLI runtime."
+            )),
+            default: "otlp-http",
+            tags: ["experimental", "advanced"],
+            included: product.quality !== "stable"
+        },
+        [AgentHostOTelOtlpEndpointSettingId]: {
+            type: "string",
+            description: ( localize(
+                5945,
+                "OTLP endpoint URL when exporter type is `otlp-http` or `otlp-grpc`. Sets `OTEL_EXPORTER_OTLP_ENDPOINT` inside the agent host process."
+            )),
+            default: "",
+            tags: ["experimental", "advanced"],
+            included: product.quality !== "stable"
+        },
+        [AgentHostOTelCaptureContentSettingId]: {
+            type: "boolean",
+            description: ( localize(
+                5946,
+                "When enabled, includes prompt and response content in OTel span attributes. Sets `OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT`. Privacy-sensitive: do not enable in environments that ship spans to shared sinks."
+            )),
+            default: false,
+            tags: ["experimental", "advanced"],
+            included: product.quality !== "stable"
+        },
+        [AgentHostOTelOutfileSettingId]: {
+            type: "string",
+            description: ( localize(
+                5947,
+                "Output path for span JSON lines when exporter type is `file`. Sets `COPILOT_OTEL_FILE_EXPORTER_PATH`."
+            )),
+            default: "",
+            tags: ["experimental", "advanced"],
+            included: product.quality !== "stable"
+        },
+        [AgentHostOTelDbSpanExporterEnabledSettingId]: {
+            type: "boolean",
+            description: ( localize(
+                5948,
+                "When enabled, the agent host persists every emitted OTel span to a local SQLite database. Spans can be inspected via the `Export Agent Host Traces Database` command. Compatible with external exporters: spans are written to SQLite *and* forwarded to the user-configured sink."
+            )),
+            default: false,
+            tags: ["experimental", "advanced"],
+            included: product.quality !== "stable"
+        },
+        [ChatConfiguration.AgentHostClientTools]: {
+            type: "array",
+            items: {
+                type: "string"
+            },
+            description: ( localize(
+                5949,
+                "Tool reference names to expose as client-provided tools in agent host sessions."
+            )),
+            default: [
+                "runTask",
+                "getTaskOutput",
+                "problems",
+                "runTests",
+                ...browserChatToolReferenceNames
+            ],
+            tags: ["experimental", "advanced"],
+            included: product.quality !== "stable"
+        },
+        [ChatConfiguration.ToolConfirmationCarousel]: {
+            type: "boolean",
+            description: ( localize(
+                5950,
+                "When enabled, multiple tool confirmations are batched into a carousel above the input."
+            )),
+            default: product.quality !== "stable",
+            tags: ["experimental"]
+        },
+        [ChatConfiguration.ToolRiskAssessmentEnabled]: {
+            type: "boolean",
+            description: ( localize(
+                5951,
+                "When enabled, terminal tool confirmations show an LLM-generated risk level (Safe / Caution / Review carefully) and a short explanation."
+            )),
+            default: true,
+            experiment: {
+                mode: "auto"
+            }
+        },
+        [ChatConfiguration.ToolRiskAssessmentModel]: {
+            type: "string",
+            description: ( localize(
+                5952,
+                "The language model id used to generate tool risk assessments. Should be a small, fast model."
+            )),
+            default: "copilot-utility-small",
+            tags: ["experimental", "advanced"],
+            experiment: {
+                mode: "auto"
+            }
+        },
+        [ChatConfiguration.PlanAgentDefaultModel]: {
+            type: "string",
+            description: ( localize(
+                5953,
+                "Select the default language model to use for the Plan agent from the available providers."
+            )),
+            default: "",
+            enum: PlanAgentDefaultModel.modelIds,
+            enumItemLabels: PlanAgentDefaultModel.modelLabels,
+            markdownEnumDescriptions: PlanAgentDefaultModel.modelDescriptions
+        },
+        [ChatConfiguration.ExploreAgentDefaultModel]: {
+            type: "string",
+            description: ( localize(
+                5954,
+                "Select the default language model to use for the Explore subagent from the available providers."
+            )),
+            default: "",
+            enum: ExploreAgentDefaultModel.modelIds,
+            enumItemLabels: ExploreAgentDefaultModel.modelLabels,
+            markdownEnumDescriptions: ExploreAgentDefaultModel.modelDescriptions
+        },
+        [ChatConfiguration.UtilityModel]: {
+            type: "string",
+            description: ( localize(
+                5955,
+                "Override the language model used by built-in utility flows (titles, summaries, fallback responses, etc.). Leave empty to use the default model."
+            )),
+            default: "",
+            enum: UtilityModelContribution.modelIds,
+            enumItemLabels: UtilityModelContribution.modelLabels,
+            markdownEnumDescriptions: UtilityModelContribution.modelDescriptions
+        },
+        [ChatConfiguration.UtilitySmallModel]: {
+            type: "string",
+            description: ( localize(
+                5956,
+                "Override the language model used by built-in small/fast utility flows (commit messages, intent detection, inline-chat progress, etc.). A fast and inexpensive model is recommended. Leave empty to use the default model."
+            )),
+            default: "",
+            enum: UtilitySmallModelContribution.modelIds,
+            enumItemLabels: UtilitySmallModelContribution.modelLabels,
+            markdownEnumDescriptions: UtilitySmallModelContribution.modelDescriptions
+        },
+        [ChatConfiguration.RequestQueueingDefaultAction]: {
+            type: "string",
+            enum: ["queue", "steer"],
+            enumDescriptions: [( localize(5957, "Queue the message to send after the current request completes.")), ( localize(
+                5958,
+                "Steer the current request by sending the message immediately, signaling the current request to yield."
+            ))],
+            description: ( localize(
+                5959,
+                "Controls which action is the default for the queue button when a request is in progress."
+            )),
+            default: "steer"
+        },
+        [ChatConfiguration.EditModeHidden]: {
+            type: "boolean",
+            description: ( localize(5960, "When enabled, hides the Edit mode from the chat mode picker.")),
+            default: true,
+            tags: ["experimental"],
+            experiment: {
+                mode: "auto"
+            },
+            policy: {
+                name: "DeprecatedEditModeHidden",
+                category: PolicyCategory.InteractiveSession,
+                minimumVersion: "1.112",
+                localization: {
+                    description: {
+                        key: "chat.editMode.hidden",
+                        value: ( localize(5960, "When enabled, hides the Edit mode from the chat mode picker."))
+                    }
+                }
+            }
+        },
+        [ChatConfiguration.EnableMath]: {
+            type: "boolean",
+            description: ( localize(5961, "Enable math rendering in chat responses using KaTeX.")),
+            default: true
+        },
+        [ChatConfiguration.ShowCodeBlockProgressAnimation]: {
+            type: "boolean",
+            description: ( localize(
+                5962,
+                "When applying edits, show a progress animation in the code block pill. If disabled, shows the progress percentage instead."
+            )),
+            default: true,
+            tags: ["experimental"]
+        },
+        [mcpDiscoverySection]: {
+            type: "object",
+            properties: Object.fromEntries(( allDiscoverySources.map(k => [k, {
+                type: "boolean",
+                description: discoverySourceSettingsLabel[k]
+            }]))),
+            additionalProperties: false,
+            default: Object.fromEntries(( allDiscoverySources.map(k => [k, false]))),
+            markdownDescription: ( localize(
+                5963,
+                "Configures discovery of Model Context Protocol servers from configuration from various other applications."
+            ))
+        },
+        [mcpGalleryServiceEnablementConfig]: {
+            type: "boolean",
+            default: false,
+            tags: ["preview"],
+            description: ( localize(
+                5964,
+                "Enables the default Marketplace for Model Context Protocol (MCP) servers."
+            )),
+            included: product.quality === "stable"
+        },
+        [mcpGalleryServiceUrlConfig]: {
+            type: "string",
+            description: ( localize(5965, "Configure the MCP Gallery service URL to connect to")),
+            default: "",
+            scope: ConfigurationScope.APPLICATION,
+            tags: ["usesOnlineServices", "advanced"],
+            included: false,
+            policy: {
+                name: "McpGalleryServiceUrl",
+                category: PolicyCategory.InteractiveSession,
+                minimumVersion: "1.101",
+                value: policyData => policyData.mcpRegistryUrl,
+                localization: {
+                    description: {
+                        key: "mcp.gallery.serviceUrl",
+                        value: ( localize(5965, "Configure the MCP Gallery service URL to connect to"))
+                    }
+                }
+            }
+        },
+        [PromptsConfig.INSTRUCTIONS_LOCATION_KEY]: {
+            type: "object",
+            title: ( localize(5966, "Instructions File Locations")),
+            markdownDescription: ( localize(
+                5967,
+                "Specify location(s) of instructions files (`*{0}`) that can be attached in Chat sessions. [Learn More]({1}).\n\nRelative paths are resolved from the root folder(s) of your workspace.",
+                INSTRUCTION_FILE_EXTENSION,
+                INSTRUCTIONS_DOCUMENTATION_URL
+            )),
+            default: {
+                ...( DEFAULT_INSTRUCTIONS_SOURCE_FOLDERS.map(folder => ({
+                    [folder.path]: true
+                }))).reduce((acc, curr) => ({
+                    ...acc,
+                    ...curr
+                }), {})
+            },
+            additionalProperties: {
+                type: "boolean"
+            },
+            propertyNames: {
+                pattern: VALID_PROMPT_FOLDER_PATTERN,
+                patternErrorMessage: ( localize(
+                    5968,
+                    "Paths must be relative or start with '~/'. Absolute paths and '\\' separators are not supported. Glob patterns are deprecated and will be removed in future versions."
+                ))
+            },
+            restricted: true,
+            tags: ["prompts", "reusable prompts", "prompt snippets", "instructions"],
+            examples: [{
+                [DEFAULT_INSTRUCTIONS_SOURCE_FOLDERS[0].path]: true
+            }, {
+                [INSTRUCTIONS_DEFAULT_SOURCE_FOLDER]: true,
+                "/Users/vscode/repos/instructions": true
+            }]
+        },
+        [PromptsConfig.PROMPT_LOCATIONS_KEY]: {
+            type: "object",
+            title: ( localize(5969, "Prompt File Locations")),
+            markdownDescription: ( localize(
+                5970,
+                "Specify location(s) of reusable prompt files (`*{0}`) that can be run in Chat sessions. [Learn More]({1}).\n\nRelative paths are resolved from the root folder(s) of your workspace.",
+                PROMPT_FILE_EXTENSION,
+                PROMPT_DOCUMENTATION_URL
+            )),
+            default: {
+                [PROMPT_DEFAULT_SOURCE_FOLDER]: true
+            },
+            additionalProperties: {
+                type: "boolean"
+            },
+            unevaluatedProperties: {
+                type: "boolean"
+            },
+            propertyNames: {
+                pattern: VALID_PROMPT_FOLDER_PATTERN,
+                patternErrorMessage: ( localize(
+                    5971,
+                    "Paths must be relative or start with '~/'. Absolute paths and '\\' separators are not supported. Glob patterns are deprecated and will be removed in future versions."
+                ))
+            },
+            restricted: true,
+            tags: ["prompts", "reusable prompts", "prompt snippets", "instructions"],
+            examples: [{
+                [PROMPT_DEFAULT_SOURCE_FOLDER]: true
+            }, {
+                [PROMPT_DEFAULT_SOURCE_FOLDER]: true,
+                "/Users/vscode/repos/prompts": true
+            }]
+        },
+        [PromptsConfig.MODE_LOCATION_KEY]: {
+            type: "object",
+            title: ( localize(5972, "Mode File Locations")),
+            markdownDescription: ( localize(
+                5973,
+                "Specify location(s) of custom chat mode files (`*{0}`). [Learn More]({1}).\n\nRelative paths are resolved from the root folder(s) of your workspace.",
+                LEGACY_MODE_FILE_EXTENSION,
+                AGENT_DOCUMENTATION_URL
+            )),
+            default: {
+                [LEGACY_MODE_DEFAULT_SOURCE_FOLDER]: true
+            },
+            deprecationMessage: ( localize(
+                5974,
+                "This setting is deprecated and will be removed in future releases. Chat modes are now called custom agents and are located in `.github/agents`"
+            )),
+            additionalProperties: {
+                type: "boolean"
+            },
+            unevaluatedProperties: {
+                type: "boolean"
+            },
+            restricted: true,
+            tags: [
+                "experimental",
+                "prompts",
+                "reusable prompts",
+                "prompt snippets",
+                "instructions"
+            ],
+            examples: [{
+                [LEGACY_MODE_DEFAULT_SOURCE_FOLDER]: true
+            }, {
+                [LEGACY_MODE_DEFAULT_SOURCE_FOLDER]: true,
+                "/Users/vscode/repos/chatmodes": true
+            }]
+        },
+        [PromptsConfig.AGENTS_LOCATION_KEY]: {
+            type: "object",
+            title: ( localize(5975, "Agent File Locations")),
+            markdownDescription: ( localize(
+                5976,
+                "Specify location(s) of custom agent files (`*{0}`). [Learn More]({1}).\n\nRelative paths are resolved from the root folder(s) of your workspace.",
+                AGENT_FILE_EXTENSION,
+                AGENT_DOCUMENTATION_URL
+            )),
+            default: {
+                [AGENTS_SOURCE_FOLDER]: true,
+                [CLAUDE_AGENTS_SOURCE_FOLDER]: true,
+                [COPILOT_USER_AGENTS_SOURCE_FOLDER]: true
+            },
+            additionalProperties: {
+                type: "boolean"
+            },
+            propertyNames: {
+                pattern: VALID_PROMPT_FOLDER_PATTERN,
+                patternErrorMessage: ( localize(
+                    5977,
+                    "Paths must be relative or start with '~/'. Absolute paths and '\\' separators are not supported."
+                ))
+            },
+            restricted: true,
+            tags: ["prompts", "reusable prompts", "prompt snippets", "instructions"],
+            examples: [{
+                [AGENTS_SOURCE_FOLDER]: true
+            }, {
+                [AGENTS_SOURCE_FOLDER]: true,
+                "my-agents": true,
+                "../shared-agents": true,
+                "~/.copilot/agents": true
+            }]
+        },
+        [PromptsConfig.USE_AGENT_MD]: {
+            type: "boolean",
+            title: ( localize(5978, "Use AGENTS.md file")),
+            markdownDescription: ( localize(
+                5979,
+                "Controls whether instructions from `AGENTS.md` file found in a workspace roots are attached to all chat requests."
+            )),
+            default: true,
+            restricted: true,
+            disallowConfigurationDefault: true,
+            tags: ["prompts", "reusable prompts", "prompt snippets", "instructions"]
+        },
+        [PromptsConfig.USE_NESTED_AGENT_MD]: {
+            type: "boolean",
+            title: ( localize(5980, "Use nested AGENTS.md files")),
+            markdownDescription: ( localize(
+                5981,
+                "Controls whether instructions from nested `AGENTS.md` files found in the workspace are listed in all chat requests. The language model can load these skills on-demand if the `read` tool is available."
+            )),
+            default: false,
+            restricted: true,
+            disallowConfigurationDefault: true,
+            tags: [
+                "experimental",
+                "prompts",
+                "reusable prompts",
+                "prompt snippets",
+                "instructions"
+            ]
+        },
+        [PromptsConfig.USE_CLAUDE_MD]: {
+            type: "boolean",
+            title: ( localize(5982, "Use CLAUDE.md file")),
+            markdownDescription: ( localize(
+                5983,
+                "Controls whether instructions from `CLAUDE.md` file found in workspace roots, .claude and ~/.claude folder are attached to all chat requests."
+            )),
+            default: true,
+            restricted: true,
+            disallowConfigurationDefault: true,
+            tags: ["prompts", "reusable prompts", "prompt snippets", "instructions"]
+        },
+        [PromptsConfig.USE_AGENT_SKILLS]: {
+            type: "boolean",
+            title: ( localize(5984, "Use Agent skills")),
+            markdownDescription: ( localize(
+                5985,
+                "Controls whether skills are provided as specialized capabilities to the chat requests. Skills are loaded from the folders configured in `#chat.agentSkillsLocations#`. The language model can load these skills on-demand if the `read` tool is available. Learn more about [Agent Skills](https://aka.ms/vscode-agent-skills)."
+            )),
+            default: true,
+            restricted: true,
+            disallowConfigurationDefault: true,
+            tags: ["prompts", "reusable prompts", "prompt snippets", "instructions"]
+        },
+        [PromptsConfig.USE_SKILL_ADHERENCE_PROMPT]: {
+            type: "boolean",
+            title: ( localize(5986, "Use Skill Adherence Prompt")),
+            markdownDescription: ( localize(
+                5987,
+                "Controls whether a stronger skill adherence prompt is used that encourages the model to immediately invoke skills when relevant rather than just announcing them."
+            )),
+            default: false,
+            restricted: true,
+            disallowConfigurationDefault: true,
+            tags: [
+                "experimental",
+                "prompts",
+                "reusable prompts",
+                "prompt snippets",
+                "instructions"
+            ],
+            experiment: {
+                mode: "auto"
+            }
+        },
+        [PromptsConfig.INCLUDE_APPLYING_INSTRUCTIONS]: {
+            type: "boolean",
+            title: ( localize(5988, "Include Applying Instructions")),
+            markdownDescription: ( localize(
+                5989,
+                "Controls whether instructions with a matching 'applyTo' attribute are automatically included in chat requests."
+            )),
+            default: true,
+            restricted: true,
+            disallowConfigurationDefault: true,
+            tags: ["prompts", "reusable prompts", "prompt snippets", "instructions"]
+        },
+        [PromptsConfig.INCLUDE_REFERENCED_INSTRUCTIONS]: {
+            type: "boolean",
+            title: ( localize(5990, "Include Referenced Instructions")),
+            markdownDescription: ( localize(
+                5991,
+                "Controls whether referenced instructions are automatically included in chat requests."
+            )),
+            default: false,
+            restricted: true,
+            disallowConfigurationDefault: true,
+            tags: ["prompts", "reusable prompts", "prompt snippets", "instructions"]
+        },
+        [PromptsConfig.USE_CUSTOMIZATIONS_IN_PARENT_REPOS]: {
+            type: "boolean",
+            title: ( localize(5992, "Use Customizations in Parent Repositories")),
+            markdownDescription: ( localize(
+                5993,
+                "Controls whether to use chat customization files in parent repositories."
+            )),
+            default: false,
+            restricted: true,
+            disallowConfigurationDefault: true,
+            tags: ["prompts", "reusable prompts", "prompt snippets", "instructions"]
+        },
+        [PromptsConfig.SKILLS_LOCATION_KEY]: {
+            type: "object",
+            title: ( localize(5994, "Agent Skills Locations")),
+            markdownDescription: ( localize(
+                5995,
+                "Specify location(s) of agent skills (`{0}`) that can be used in Chat Sessions. [Learn More]({1}).\n\nEach path should contain skill subfolders with SKILL.md files (e.g., add `my-skills` if you have `my-skills/skillA/SKILL.md`). Relative paths are resolved from the root folder(s) of your workspace.",
+                SKILL_FILENAME,
+                SKILL_DOCUMENTATION_URL
+            )),
+            default: {
+                ...( DEFAULT_SKILL_SOURCE_FOLDERS.map(folder => ({
+                    [folder.path]: true
+                }))).reduce((acc, curr) => ({
+                    ...acc,
+                    ...curr
+                }), {})
+            },
+            additionalProperties: {
+                type: "boolean"
+            },
+            propertyNames: {
+                pattern: VALID_PROMPT_FOLDER_PATTERN,
+                patternErrorMessage: ( localize(
+                    5996,
+                    "Paths must be relative or start with '~/'. Absolute paths and '\\' separators are not supported."
+                ))
+            },
+            restricted: true,
+            tags: ["prompts", "reusable prompts", "prompt snippets", "instructions"],
+            examples: [{
+                [DEFAULT_SKILL_SOURCE_FOLDERS[0].path]: true
+            }, {
+                [DEFAULT_SKILL_SOURCE_FOLDERS[0].path]: true,
+                "my-skills": true,
+                "../shared-skills": true,
+                "~/.custom/skills": true
+            }]
+        },
+        [PromptsConfig.HOOKS_LOCATION_KEY]: {
+            type: "object",
+            title: ( localize(5997, "Hook File Locations")),
+            markdownDescription: ( localize(
+                5998,
+                "Specify paths to hook configuration files that define custom shell commands to execute at strategic points in an agent's workflow. [Learn More]({0}).\n\nRelative paths are resolved from the root folder(s) of your workspace. Supports Copilot hooks (`*.json`) and Claude Code hooks (`settings.json`, `settings.local.json`).",
+                HOOK_DOCUMENTATION_URL
+            )),
+            default: {
+                ...( DEFAULT_HOOK_FILE_PATHS.map(f => ({
+                    [f.path]: true
+                }))).reduce((acc, curr) => ({
+                    ...acc,
+                    ...curr
+                }), {})
+            },
+            additionalProperties: {
+                type: "boolean"
+            },
+            propertyNames: {
+                pattern: VALID_PROMPT_FOLDER_PATTERN,
+                patternErrorMessage: ( localize(
+                    5999,
+                    "Paths must be relative or start with '~/'. Absolute paths and '\\' separators are not supported."
+                ))
+            },
+            restricted: true,
+            tags: ["preview", "prompts", "hooks", "agent"],
+            examples: [{
+                [DEFAULT_HOOK_FILE_PATHS[0].path]: true
+            }, {
+                [DEFAULT_HOOK_FILE_PATHS[0].path]: true,
+                "custom-hooks/hooks.json": true
+            }],
+            agentsWindow: {
+                default: {
+                    ".claude/settings.local.json": false,
+                    ".claude/settings.json": false,
+                    "~/.claude/settings.json": false
+                }
+            }
+        },
+        [PromptsConfig.USE_CHAT_HOOKS]: {
+            type: "boolean",
+            title: ( localize(6000, "Use Chat Hooks")),
+            markdownDescription: ( localize(
+                6001,
+                "Controls whether chat hooks are executed at strategic points during an agent's workflow. Hooks are loaded from the files configured in `#chat.hookFilesLocations#`."
+            )),
+            default: true,
+            restricted: true,
+            disallowConfigurationDefault: true,
+            tags: ["preview", "prompts", "hooks", "agent"],
+            policy: {
+                name: "ChatHooks",
+                category: PolicyCategory.InteractiveSession,
+                minimumVersion: "1.109",
+                value: policyData => policyData.chat_preview_features_enabled === false ? false : undefined,
+                localization: {
+                    description: {
+                        key: "chat.useHooks.description",
+                        value: ( localize(
+                            6001,
+                            "Controls whether chat hooks are executed at strategic points during an agent's workflow. Hooks are loaded from the files configured in `#chat.hookFilesLocations#`."
+                        ))
+                    }
+                }
+            }
+        },
+        [PromptsConfig.USE_CLAUDE_HOOKS]: {
+            type: "boolean",
+            title: ( localize(6002, "Use Claude Hooks")),
+            markdownDescription: ( localize(
+                6003,
+                "Controls whether hooks from Claude configuration files can execute. When disabled, only Copilot-format hooks are used. Hooks are loaded from the files configured in `#chat.hookFilesLocations#`."
+            )),
+            default: false,
+            restricted: true,
+            disallowConfigurationDefault: true,
+            tags: ["preview", "prompts", "hooks", "agent"]
+        },
+        [PromptsConfig.PROMPT_FILES_SUGGEST_KEY]: {
+            type: "object",
+            scope: ConfigurationScope.RESOURCE,
+            title: ( localize(6004, "Prompt File Recommendations")),
+            markdownDescription: ( localize(
+                6005,
+                "Configure which prompt files to recommend in the chat welcome view. Each key is a prompt file name, and the value can be `true` to always recommend, `false` to never recommend, or a [when clause](https://aka.ms/vscode-when-clause) expression like `resourceExtname == .js` or `resourceLangId == markdown`."
+            )),
+            default: {},
+            additionalProperties: {
+                oneOf: [{
+                    type: "boolean"
+                }, {
+                    type: "string"
+                }]
+            },
+            tags: ["prompts", "reusable prompts", "prompt snippets", "instructions"],
+            examples: [{
+                "plan": true,
+                "a11y-audit": "resourceExtname == .html",
+                "document": "resourceLangId == markdown"
+            }]
+        },
+        [ChatConfiguration.TodosShowWidget]: {
+            type: "boolean",
+            default: true,
+            description: ( localize(
+                6006,
+                "Controls whether to show the todo list widget above the chat input. When enabled, the widget displays todo items created by the agent and updates as progress is made."
+            ))
+        },
+        [ChatConfiguration.ThinkingStyle]: {
+            type: "string",
+            default: "fixedScrolling",
+            enum: ["collapsed", "collapsedPreview", "fixedScrolling"],
+            enumDescriptions: [( localize(6007, "Thinking parts will be collapsed by default.")), ( localize(
+                6008,
+                "Thinking parts will be expanded first, then collapse once we reach a part that is not thinking."
+            )), ( localize(
+                6009,
+                "Show thinking in a fixed-height streaming panel that auto-scrolls; click header to expand to full height."
+            ))],
+            description: ( localize(6010, "Controls how thinking is rendered.")),
+            tags: ["experimental"]
+        },
+        [ChatConfiguration.ThinkingGenerateTitles]: {
+            type: "boolean",
+            default: true,
+            description: ( localize(
+                6011,
+                "Controls whether to use an LLM to generate summary titles for thinking sections."
+            )),
+            tags: ["experimental"]
+        },
+        "chat.agent.thinking.collapsedTools": {
+            type: "string",
+            default: "always",
+            enum: ["off", "withThinking", "always"],
+            enumDescriptions: [( localize(6012, "Tool calls are shown separately, not collapsed into thinking.")), ( localize(
+                6013,
+                "Tool calls are collapsed into thinking sections when thinking is present."
+            )), ( localize(6014, "Tool calls are always collapsed, even without thinking."))],
+            markdownDescription: ( localize(
+                6015,
+                "Controls how tool calls are displayed in relation to thinking sections."
+            )),
+            tags: ["experimental"]
+        },
+        [ChatConfiguration.TerminalToolsInThinking]: {
+            type: "boolean",
+            default: true,
+            markdownDescription: ( localize(
+                6016,
+                "When enabled, terminal tool calls are displayed inside the thinking dropdown with a simplified view."
+            )),
+            tags: ["experimental"]
+        },
+        [ChatConfiguration.SimpleTerminalCollapsible]: {
+            type: "boolean",
+            default: true,
+            markdownDescription: ( localize(
+                6017,
+                "When enabled, terminal tool calls are always displayed in a collapsible container with a simplified view."
+            )),
+            tags: ["experimental"]
+        },
+        [ChatConfiguration.CompressOutputEnabled]: {
+            type: "boolean",
+            default: false,
+            markdownDescription: ( localize(
+                6018,
+                "Post-process tool output (for example `git diff`, `ls -l`, or `npm install`) to reduce token usage before it is sent to the model."
+            )),
+            tags: ["preview"],
+            experiment: {
+                mode: "auto"
+            }
+        },
+        [ChatConfiguration.ThinkingPhrases]: {
+            type: "object",
+            default: {
+                mode: "append",
+                phrases: []
+            },
+            properties: {
+                mode: {
+                    type: "string",
+                    enum: ["replace", "append"],
+                    default: "append",
+                    description: ( localize(
+                        6019,
+                        "'replace' replaces all default phrases entirely; 'append' adds your phrases to all default categories."
+                    ))
+                },
+                phrases: {
+                    type: "array",
+                    items: {
+                        type: "string"
+                    },
+                    default: [],
+                    description: ( localize(
+                        6020,
+                        "Custom loading messages to show during thinking, working progress, terminal, and tool operations."
+                    ))
+                }
+            },
+            additionalProperties: false,
+            markdownDescription: ( localize(
+                6021,
+                "Customize the loading messages shown during agent thinking and progress indicators. Use `\"mode\": \"replace\"` to use only your phrases, or `\"mode\": \"append\"` to add them to the defaults."
+            )),
+            tags: ["experimental"]
+        },
+        [ChatConfiguration.AutoExpandToolFailures]: {
+            type: "boolean",
+            default: true,
+            markdownDescription: ( localize(
+                6022,
+                "When enabled, tool failures are automatically expanded in the chat UI to show error details."
+            ))
+        },
+        [ChatConfiguration.AIDisabled]: {
+            type: "boolean",
+            description: ( localize(
+                6023,
+                "Disable and hide built-in AI features provided by GitHub Copilot, including chat and inline suggestions."
+            )),
+            default: false,
+            scope: ConfigurationScope.WINDOW,
+            policy: {
+                name: "ChatAIFeaturesDisabled",
+                category: PolicyCategory.InteractiveSession,
+                minimumVersion: "1.111",
+                localization: {
+                    description: {
+                        key: "chat.disableAIFeatures",
+                        value: ( localize(
+                            6023,
+                            "Disable and hide built-in AI features provided by GitHub Copilot, including chat and inline suggestions."
+                        ))
+                    }
+                }
+            }
+        },
+        [ChatConfiguration.OfflineByok]: {
+            type: "boolean",
+            description: ( localize(6024, "Experimental: enable BYOK chat features without GitHub sign-in.")),
+            default: false,
+            scope: ConfigurationScope.WINDOW,
+            included: false
+        },
+        [ChatConfiguration.TitleBarSignInEnabled]: {
+            type: "boolean",
+            description: ( localize(
+                6025,
+                "Controls whether the Copilot Sign In button is shown in the title bar when signed out. When disabled, the Sign In affordance falls back to the status bar."
+            )),
+            default: true
+        },
+        "chat.approvedAccountOrganizations": {
+            type: "array",
+            items: {
+                type: "string"
+            },
+            description: ( localize(
+                6026,
+                "List of GitHub organization logins whose members are permitted to use AI features. When set to a non-empty list, AI features are disabled until the user signs into a GitHub account that belongs to one of the specified organizations and account-level policy data has been resolved. Set to '*' to allow any authenticated GitHub or GitHub Enterprise account."
+            )),
+            default: [],
+            included: false,
+            policy: {
+                name: "ChatApprovedAccountOrganizations",
+                category: PolicyCategory.InteractiveSession,
+                minimumVersion: "1.118",
+                localization: {
+                    description: {
+                        key: "chat.approvedAccountOrganizations.policy.description",
+                        value: ( localize(
+                            6027,
+                            "Setting this policy to a non-empty list activates the Approved Account gate: all AI features are disabled until the user signs into a GitHub account whose organizations intersect this list AND the account-side policy data has resolved. Comparison is case-insensitive. Use '*' as a wildcard to accept any signed-in GitHub or GHE account (use this for GHE deployments where the organization list is not surfaced)."
+                        ))
+                    }
+                }
+            }
+        },
+        "chat.allowAnonymousAccess": {
+            type: "boolean",
+            description: ( localize(6028, "Controls whether anonymous access is allowed in chat.")),
+            default: false,
+            tags: ["experimental"],
+            experiment: {
+                mode: "auto"
+            }
+        },
+        [ChatConfiguration.GrowthNotificationEnabled]: {
+            type: "boolean",
+            description: ( localize(
+                6029,
+                "Controls whether to show a growth notification in the agent sessions view to encourage new users to try Copilot."
+            )),
+            default: false,
+            tags: ["experimental"],
+            experiment: {
+                mode: "auto"
+            }
+        },
+        [ChatConfiguration.RestoreLastPanelSession]: {
+            type: "boolean",
+            description: ( localize(
+                6030,
+                "Controls whether the last session is restored in panel after restart."
+            )),
+            default: false
+        },
+        [ChatConfiguration.ExitAfterDelegation]: {
+            type: "boolean",
+            description: ( localize(
+                6031,
+                "Controls whether the chat panel automatically exits after delegating a request to another session."
+            )),
+            default: false,
+            tags: ["preview"]
+        },
+        "chat.extensionUnification.enabled": {
+            type: "boolean",
+            description: ( localize(
+                6032,
+                "Enables the unification of GitHub Copilot extensions. When enabled, all GitHub Copilot functionality is served from the GitHub Copilot Chat extension. When disabled, the GitHub Copilot and GitHub Copilot Chat extensions operate independently."
+            )),
+            default: true,
+            tags: ["experimental"],
+            experiment: {
+                mode: "auto"
+            }
+        },
+        [ChatConfiguration.GeneralPurposeAgentEnabled]: {
+            type: "boolean",
+            description: ( localize(
+                6033,
+                "Controls whether the built-in General Purpose agent is available as a subagent."
+            )),
+            default: false,
+            tags: ["experimental", "advanced"],
+            experiment: {
+                mode: "auto"
+            }
+        },
+        [ChatConfiguration.SubagentsAllowInvocationsFromSubagents]: {
+            type: "boolean",
+            description: ( localize(6034, "Allow subagents to invoke subagents.")),
+            markdownDescription: ( localize(
+                6035,
+                "Controls whether subagents can invoke other subagents. When enabled, nesting is limited to a maximum depth of 5."
+            )),
+            default: false,
+            experiment: {
+                mode: "auto"
+            }
+        },
+        [ChatConfiguration.ChatCustomizationHarnessSelectorEnabled]: {
+            type: "boolean",
+            tags: ["preview"],
+            description: ( localize(
+                6036,
+                "Controls whether the harness selector is shown in the Chat Customizations editor sidebar. When disabled, the editor always shows all customizations without filtering."
+            )),
+            default: true
+        },
+        [ChatConfiguration.ChatCustomizationsStructuredPreviewEnabled]: {
+            type: "boolean",
+            tags: ["preview"],
+            description: ( localize(
+                6037,
+                "Controls whether the Chat Customizations editor shows a structured preview for markdown customization files (agents, skills, instructions, prompts). When disabled, the editor always opens the raw markdown in the embedded code editor."
+            )),
+            default: false
+        },
+        [ChatConfiguration.UseChatSessionCustomizationsForCustomAgents]: {
+            type: "boolean",
+            description: ( localize(
+                6038,
+                "When enabled, custom agents shown in the chat mode picker are sourced from the customization harness service (scoped per session type) instead of the prompts service."
+            )),
+            default: false,
+            tags: ["experimental", "advanced"],
+            experiment: {
+                mode: "auto"
+            }
+        }
+    }
+});
+( Registry.as(EditorExtensions.EditorPane)).registerEditorPane(
+    EditorPaneDescriptor.create(ChatEditor, ChatEditorInput.EditorID, ( localize(6039, "Chat"))),
+    [( new SyncDescriptor(ChatEditorInput))]
+);
+( Registry.as(EditorExtensions.EditorPane)).registerEditorPane(
+    EditorPaneDescriptor.create(ChatDebugEditor, ChatDebugEditorInput.ID, ( localize(6040, "Debug View"))),
+    [( new SyncDescriptor(ChatDebugEditorInput))]
+);
+( Registry.as(EditorExtensions.EditorPane)).registerEditorPane(
+    EditorPaneDescriptor.create(AgentPluginEditor, AgentPluginEditor.ID, ( localize(6041, "Agent Plugin"))),
+    [( new SyncDescriptor(AgentPluginEditorInput))]
+);
+( Registry.as(Extensions$2.ConfigurationMigration)).registerConfigurationMigrations([{
+    key: "chat.experimental.detectParticipant.enabled",
+    migrateFn: (value, _accessor) => ([["chat.experimental.detectParticipant.enabled", {
+        value: undefined
+    }], ["chat.detectParticipant.enabled", {
+        value: value !== false
+    }]])
+}, {
+    key: "chat.useClaudeSkills",
+    migrateFn: (value, _accessor) => ([["chat.useClaudeSkills", {
+        value: undefined
+    }], ["chat.useAgentSkills", {
+        value
+    }]])
+}, {
+    key: mcpDiscoverySection,
+    migrateFn: value => {
+        if (typeof value === "boolean") {
+            return {
+                value: Object.fromEntries(( allDiscoverySources.map(k => [k, value])))
+            };
+        }
+        return {
+            value
+        };
+    }
+}, {
+    key: ChatConfiguration.NotifyWindowOnConfirmation,
+    migrateFn: value => {
+        if (value === true) {
+            return {
+                value: ChatNotificationMode.WindowNotFocused
+            };
+        } else if (value === false) {
+            return {
+                value: ChatNotificationMode.Off
+            };
+        }
+        return [];
+    }
+}, {
+    key: ChatConfiguration.NotifyWindowOnResponseReceived,
+    migrateFn: value => {
+        if (value === true) {
+            return {
+                value: ChatNotificationMode.WindowNotFocused
+            };
+        } else if (value === false) {
+            return {
+                value: ChatNotificationMode.Off
+            };
+        }
+        return [];
+    }
+}, {
+    key: "chat.plugins.paths",
+    migrateFn: (value, _accessor) => ([["chat.plugins.paths", {
+        value: undefined
+    }], [ChatConfiguration.PluginLocations, {
+        value
+    }]])
+}, {
+    key: AgentNetworkDomainSettingId.DeprecatedSandboxAllowedNetworkDomains,
+    migrateFn: (value, accessor) => {
+        const pairs = [];
+        pairs.push([AgentNetworkDomainSettingId.DeprecatedSandboxAllowedNetworkDomains, {
+            value: undefined
+        }]);
+        if (value !== undefined && accessor(AgentNetworkDomainSettingId.AllowedNetworkDomains) === undefined) {
+            pairs.push([AgentNetworkDomainSettingId.AllowedNetworkDomains, {
+                value
+            }]);
+        }
+        return pairs;
+    }
+}, {
+    key: AgentNetworkDomainSettingId.DeprecatedSandboxDeniedNetworkDomains,
+    migrateFn: (value, accessor) => {
+        const pairs = [];
+        pairs.push([AgentNetworkDomainSettingId.DeprecatedSandboxDeniedNetworkDomains, {
+            value: undefined
+        }]);
+        if (value !== undefined && accessor(AgentNetworkDomainSettingId.DeniedNetworkDomains) === undefined) {
+            pairs.push([AgentNetworkDomainSettingId.DeniedNetworkDomains, {
+                value
+            }]);
+        }
+        return pairs;
+    }
+}, {
+    key: AgentNetworkDomainSettingId.DeprecatedOldAllowedNetworkDomains,
+    migrateFn: (value, accessor) => {
+        const pairs = [];
+        pairs.push([AgentNetworkDomainSettingId.DeprecatedOldAllowedNetworkDomains, {
+            value: undefined
+        }]);
+        if (value !== undefined && accessor(AgentNetworkDomainSettingId.AllowedNetworkDomains) === undefined) {
+            pairs.push([AgentNetworkDomainSettingId.AllowedNetworkDomains, {
+                value
+            }]);
+        }
+        return pairs;
+    }
+}, {
+    key: AgentNetworkDomainSettingId.DeprecatedOldDeniedNetworkDomains,
+    migrateFn: (value, accessor) => {
+        const pairs = [];
+        pairs.push([AgentNetworkDomainSettingId.DeprecatedOldDeniedNetworkDomains, {
+            value: undefined
+        }]);
+        if (value !== undefined && accessor(AgentNetworkDomainSettingId.DeniedNetworkDomains) === undefined) {
+            pairs.push([AgentNetworkDomainSettingId.DeniedNetworkDomains, {
+                value
+            }]);
+        }
+        return pairs;
+    }
+}]);
+let ChatResolverContribution = class ChatResolverContribution extends Disposable {
+    static {
+        this.ID = "workbench.contrib.chatResolver";
+    }
+    constructor(chatSessionsService, editorResolverService, instantiationService) {
+        super();
+        this.editorResolverService = editorResolverService;
+        this.instantiationService = instantiationService;
+        this._editorRegistrations = this._register(( new DisposableMap()));
+        this._registerEditor(Schemas.vscodeChatEditor);
+        this._registerEditor(Schemas.vscodeLocalChatSession);
+        this._register(chatSessionsService.onDidChangeContentProviderSchemes(e => {
+            for (const scheme of e.added) {
+                this._registerEditor(scheme);
+            }
+            for (const scheme of e.removed) {
+                this._editorRegistrations.deleteAndDispose(scheme);
+            }
+        }));
+        for (const scheme of chatSessionsService.getContentProviderSchemes()) {
+            this._registerEditor(scheme);
+        }
+    }
+    _registerEditor(scheme) {
+        this._editorRegistrations.set(scheme, this.editorResolverService.registerEditor(`${scheme}:**/**`, {
+            id: ChatEditorInput.EditorID,
+            label: ( localize(6039, "Chat")),
+            priority: RegisteredEditorPriority.builtin
+        }, {
+            singlePerResource: true,
+            canSupportResource: resource => resource.scheme === scheme
+        }, {
+            createEditorInput: (
+                {
+                    resource,
+                    options
+                }
+            ) => {
+                return {
+                    editor: this.instantiationService.createInstance(ChatEditorInput, resource, options),
+                    options
+                };
+            }
+        }));
+    }
+};
+ChatResolverContribution = ( __decorate([( __param(0, IChatSessionsService)), ( __param(1, IEditorResolverService)), ( __param(2, IInstantiationService))], ChatResolverContribution));
+let CopilotTelemetryContribution = class CopilotTelemetryContribution extends Disposable {
+    static {
+        this.ID = "workbench.contrib.copilotTelemetry";
+    }
+    constructor(telemetryService, chatEntitlementService) {
+        super();
+        this.telemetryService = telemetryService;
+        this.chatEntitlementService = chatEntitlementService;
+        this.updateCopilotTrackingId();
+        this._register(this.chatEntitlementService.onDidChangeEntitlement(() => {
+            this.updateCopilotTrackingId();
+        }));
+    }
+    updateCopilotTrackingId() {
+        const copilotTrackingId = this.chatEntitlementService.copilotTrackingId;
+        if (copilotTrackingId) {
+            this.telemetryService.setCommonProperty("common.copilotTrackingId", copilotTrackingId);
+        }
+    }
+};
+CopilotTelemetryContribution = ( __decorate([( __param(0, ITelemetryService)), ( __param(1, IChatEntitlementService))], CopilotTelemetryContribution));
+let ChatDebugResolverContribution = class ChatDebugResolverContribution {
+    static {
+        this.ID = "workbench.contrib.chatDebugResolver";
+    }
+    constructor(editorResolverService) {
+        editorResolverService.registerEditor(`${ChatDebugEditorInput.RESOURCE.scheme}:**/**`, {
+            id: ChatDebugEditorInput.ID,
+            label: ( localize(6040, "Debug View")),
+            priority: RegisteredEditorPriority.exclusive
+        }, {
+            singlePerResource: true,
+            canSupportResource: resource => resource.scheme === ChatDebugEditorInput.RESOURCE.scheme
+        }, {
+            createEditorInput: () => {
+                return {
+                    editor: ChatDebugEditorInput.instance,
+                    options: {
+                        pinned: true
+                    }
+                };
+            }
+        });
+    }
+};
+ChatDebugResolverContribution = ( __decorate([( __param(0, IEditorResolverService))], ChatDebugResolverContribution));
+let ChatAgentSettingContribution = class ChatAgentSettingContribution extends Disposable {
+    static {
+        this.ID = "workbench.contrib.chatAgentSetting";
+    }
+    constructor(experimentService, entitlementService, contextKeyService) {
+        super();
+        this.experimentService = experimentService;
+        this.entitlementService = entitlementService;
+        this.contextKeyService = contextKeyService;
+        this.newChatButtonExperimentIcon = ChatContextKeys.newChatButtonExperimentIcon.bindTo(this.contextKeyService);
+        this.registerMaxRequestsSetting();
+        this.registerNewChatButtonIcon();
+        this.registerDefaultModeSetting();
+    }
+    registerMaxRequestsSetting() {
+        let lastNode;
+        const registerMaxRequestsSetting = () => {
+            const treatmentId = this.entitlementService.entitlement === ChatEntitlement.Free ? "chatAgentMaxRequestsFree" : "chatAgentMaxRequestsPro";
+            this.experimentService.getTreatment(treatmentId).then(value => {
+                const node = {
+                    id: "chatSidebar",
+                    title: ( localize(5806, "Chat")),
+                    type: "object",
+                    properties: {
+                        "chat.agent.maxRequests": {
+                            type: "number",
+                            markdownDescription: ( localize(
+                                6042,
+                                "The maximum number of requests to allow per-turn when using an agent. When the limit is reached, will ask to confirm to continue."
+                            )),
+                            default: value ?? 50,
+                            order: 2,
+                            agentsWindow: {
+                                default: 1000
+                            }
+                        }
+                    }
+                };
+                configurationRegistry.updateConfigurations({
+                    remove: lastNode ? [lastNode] : [],
+                    add: [node]
+                });
+                lastNode = node;
+            });
+        };
+        this._register(Event.runAndSubscribe(
+            Event.debounce(this.entitlementService.onDidChangeEntitlement, () => {}, 1000),
+            () => registerMaxRequestsSetting()
+        ));
+    }
+    registerNewChatButtonIcon() {
+        this.experimentService.getTreatment("chatNewButtonIcon").then(value => {
+            const supportedValues = ["copilot", "new-session", "comment"];
+            if (typeof value === "string" && supportedValues.includes(value)) {
+                this.newChatButtonExperimentIcon.set(value);
+            } else {
+                this.newChatButtonExperimentIcon.reset();
+            }
+        });
+    }
+    registerDefaultModeSetting() {
+        this.experimentService.getTreatment("chatDefaultNewSessionMode").then(value => {
+            const node = {
+                id: "chatSidebar",
+                title: ( localize(5806, "Chat")),
+                type: "object",
+                properties: {
+                    [ChatConfiguration.DefaultNewSessionMode]: {
+                        type: "string",
+                        description: ( localize(
+                            5937,
+                            "The default mode for new chat sessions. When empty, the chat view's default mode is used."
+                        )),
+                        default: typeof value === "string" ? value : ""
+                    }
+                }
+            };
+            configurationRegistry.updateConfigurations({
+                add: [node],
+                remove: []
+            });
+        });
+    }
+};
+ChatAgentSettingContribution = ( __decorate([( __param(0, IWorkbenchAssignmentService)), ( __param(1, IChatEntitlementService)), ( __param(2, IContextKeyService))], ChatAgentSettingContribution));
+let ChatForegroundSessionCountContribution = class ChatForegroundSessionCountContribution extends Disposable {
+    static {
+        this.ID = "workbench.contrib.chatForegroundSessionCount";
+    }
+    constructor(contextKeyService, chatWidgetService, viewsService, editorService) {
+        super();
+        this.contextKeyService = contextKeyService;
+        this.chatWidgetService = chatWidgetService;
+        this.viewsService = viewsService;
+        this.editorService = editorService;
+        this.foregroundSessionCountContextKey = ChatContextKeys.foregroundSessionCount.bindTo(this.contextKeyService);
+        this._register(this.chatWidgetService.onDidAddWidget(() => {
+            this.updateForegroundSessionCount();
+        }));
+        this._register(this.editorService.onDidVisibleEditorsChange(() => {
+            this.updateForegroundSessionCount();
+        }));
+        this._register(
+            Event.filter(this.viewsService.onDidChangeViewVisibility, e => e.id === ChatViewId)(() => {
+                this.updateForegroundSessionCount();
+            })
+        );
+        this.updateForegroundSessionCount();
+    }
+    updateForegroundSessionCount() {
+        let count = this.viewsService.isViewVisible(ChatViewId) ? 1 : 0;
+        for (const widget of this.chatWidgetService.getWidgetsByLocations(ChatAgentLocation.Chat)) {
+            if (widget.domNode.offsetParent === null) {
+                continue;
+            }
+            if (isIChatViewViewContext(widget.viewContext)) {
+                continue;
+            }
+            if (isIChatResourceViewContext(widget.viewContext) && widget.viewContext.isQuickChat) {
+                continue;
+            }
+            count++;
+        }
+        this.foregroundSessionCountContextKey.set(count);
+    }
+};
+ChatForegroundSessionCountContribution = ( __decorate([( __param(0, IContextKeyService)), ( __param(1, IChatWidgetService)), ( __param(2, IViewsService)), ( __param(3, IEditorService))], ChatForegroundSessionCountContribution));
+function getCustomModesWithUniqueNames(builtinModes, customModes) {
+    const customModeIds = ( new Set());
+    const builtinNames = ( new Set(( builtinModes.map(mode => mode.name.get()))));
+    const customNameToId = ( new Map());
+    for (const mode of customModes) {
+        const modeName = mode.name.get();
+        if (( builtinNames.has(modeName))) {
+            continue;
+        }
+        const existingId = customNameToId.get(modeName);
+        if (existingId) {
+            customModeIds.delete(existingId);
+        }
+        customNameToId.set(modeName, mode.id);
+        customModeIds.add(mode.id);
+    }
+    return customModeIds;
+}
+let ChatAgentActionsContribution = class ChatAgentActionsContribution extends Disposable {
+    static {
+        this.ID = "workbench.contrib.chatAgentActions";
+    }
+    constructor(_chatModeService, chatWidgetService) {
+        super();
+        this.chatWidgetService = chatWidgetService;
+        this._modeActionDisposables = ( new DisposableMap());
+        this._store.add(this._modeActionDisposables);
+        const focusedWidget = observableFromEvent(
+            this,
+            this.chatWidgetService.onDidChangeFocusedSession,
+            () => this.chatWidgetService.lastFocusedWidget
+        );
+        this._register(autorun(reader => {
+            const chatModes = focusedWidget.read(reader)?.input.currentChatModesObs.read(reader);
+            this._syncModeActions(chatModes);
+        }));
+    }
+    _syncModeActions(chatModes) {
+        if (!chatModes) {
+            this._modeActionDisposables.clearAndDisposeAll();
+            return;
+        }
+        const {
+            builtin,
+            custom
+        } = chatModes;
+        const currentModeIds = getCustomModesWithUniqueNames(builtin, custom);
+        for (const modeId of ( this._modeActionDisposables.keys())) {
+            if (!( currentModeIds.has(modeId))) {
+                this._modeActionDisposables.deleteAndDispose(modeId);
+            }
+        }
+        for (const mode of custom) {
+            if (( currentModeIds.has(mode.id)) && !( this._modeActionDisposables.has(mode.id))) {
+                this._registerModeAction(mode);
+            }
+        }
+    }
+    _registerModeAction(mode) {
+        const actionClass = class extends ModeOpenChatGlobalAction {
+            constructor() {
+                super(mode);
+            }
+        };
+        this._modeActionDisposables.set(mode.id, registerAction2(actionClass));
+    }
+};
+ChatAgentActionsContribution = ( __decorate([( __param(0, IChatModeService)), ( __param(1, IChatWidgetService))], ChatAgentActionsContribution));
+let HookSchemaAssociationContribution = class HookSchemaAssociationContribution extends Disposable {
+    static {
+        this.ID = "workbench.contrib.hookSchemaAssociation";
+    }
+    constructor(_configurationService, _pathService) {
+        super();
+        this._configurationService = _configurationService;
+        this._pathService = _pathService;
+        this._registrations = this._register(( new DisposableStore()));
+        this._updateAssociations();
+        this._register(this._configurationService.onDidChangeConfiguration(e => {
+            if (e.affectsConfiguration(PromptsConfig.HOOKS_LOCATION_KEY)) {
+                this._updateAssociations();
+            }
+        }));
+    }
+    async _updateAssociations() {
+        this._registrations.clear();
+        const folders = PromptsConfig.promptSourceFolders(this._configurationService, PromptsType.hook);
+        const userHomeUri = await this._pathService.userHome();
+        const userHome = userHomeUri.fsPath ?? userHomeUri.path;
+        for (const folder of folders) {
+            if (folder.source === PromptFileSource.ClaudeWorkspace || folder.source === PromptFileSource.ClaudeWorkspaceLocal || folder.source === PromptFileSource.ClaudePersonal) {
+                continue;
+            }
+            const resolvedPath = isTildePath(folder.path) ? userHome + folder.path.substring(1) : folder.path;
+            const glob = resolvedPath.toLowerCase().endsWith(".json") ? resolvedPath : `${resolvedPath}/*.json`;
+            this._registrations.add(jsonContributionRegistry.registerSchemaAssociation(HOOK_SCHEMA_URI, glob));
+        }
+    }
+};
+HookSchemaAssociationContribution = ( __decorate([( __param(0, IConfigurationService)), ( __param(1, IPathService))], HookSchemaAssociationContribution));
+let ToolReferenceNamesContribution = class ToolReferenceNamesContribution extends Disposable {
+    static {
+        this.ID = "workbench.contrib.toolReferenceNames";
+    }
+    constructor(_languageModelToolsService) {
+        super();
+        this._languageModelToolsService = _languageModelToolsService;
+        this._updateToolReferenceNames();
+        this._register(
+            this._languageModelToolsService.onDidChangeTools(() => this._updateToolReferenceNames())
+        );
+    }
+    _updateToolReferenceNames() {
+        const tools = Array.from(this._languageModelToolsService.getAllToolsIncludingDisabled()).filter(tool => typeof tool.toolReferenceName === "string").sort((a, b) => a.toolReferenceName.localeCompare(b.toolReferenceName));
+        toolReferenceNameEnumValues.length = 0;
+        toolReferenceNameEnumDescriptions.length = 0;
+        for (const tool of tools) {
+            toolReferenceNameEnumValues.push(tool.toolReferenceName);
+            toolReferenceNameEnumDescriptions.push(( localize(
+                6043,
+                "{0} - {1}",
+                tool.toolReferenceName,
+                tool.userDescription || tool.displayName
+            )));
+        }
+        configurationRegistry.notifyConfigurationSchemaUpdated({
+            id: "chatSidebar",
+            properties: {
+                [ChatConfiguration.EligibleForAutoApproval]: {}
+            }
+        });
+    }
+};
+ToolReferenceNamesContribution = ( __decorate([( __param(0, ILanguageModelToolsService))], ToolReferenceNamesContribution));
+AccessibleViewRegistry.register(( new ChatTerminalOutputAccessibleView()));
+AccessibleViewRegistry.register(( new ChatResponseAccessibleView()));
+AccessibleViewRegistry.register(( new PanelChatAccessibilityHelp()));
+AccessibleViewRegistry.register(( new QuickChatAccessibilityHelp()));
+AccessibleViewRegistry.register(( new EditsChatAccessibilityHelp()));
+AccessibleViewRegistry.register(( new AgentChatAccessibilityHelp()));
+registerEditorFeature(ChatInputBoxContentProvider);
+( Registry.as(EditorExtensions.EditorFactory)).registerEditorSerializer(ChatEditorInput.TypeID, ChatEditorInputSerializer);
+( Registry.as(EditorExtensions.EditorFactory)).registerEditorSerializer(ChatDebugEditorInput.ID, ChatDebugEditorInputSerializer);
+registerWorkbenchContribution2(
+    CopilotTelemetryContribution.ID,
+    CopilotTelemetryContribution,
+    WorkbenchPhase.BlockRestore
+);
+registerWorkbenchContribution2(
+    ChatResolverContribution.ID,
+    ChatResolverContribution,
+    WorkbenchPhase.BlockStartup
+);
+registerWorkbenchContribution2(
+    ChatDebugResolverContribution.ID,
+    ChatDebugResolverContribution,
+    WorkbenchPhase.BlockStartup
+);
+registerWorkbenchContribution2(
+    PromptsDebugContribution.ID,
+    PromptsDebugContribution,
+    WorkbenchPhase.BlockRestore
+);
+registerWorkbenchContribution2(
+    ChatLanguageModelsDataContribution.ID,
+    ChatLanguageModelsDataContribution,
+    WorkbenchPhase.BlockRestore
+);
+registerWorkbenchContribution2(
+    ChatSlashCommandsContribution.ID,
+    ChatSlashCommandsContribution,
+    WorkbenchPhase.Eventually
+);
+registerWorkbenchContribution2(
+    ChatSessionOptionSlashCommandsContribution.ID,
+    ChatSessionOptionSlashCommandsContribution,
+    WorkbenchPhase.Eventually
+);
+registerWorkbenchContribution2(
+    ChatExtensionPointHandler.ID,
+    ChatExtensionPointHandler,
+    WorkbenchPhase.BlockStartup
+);
+registerWorkbenchContribution2(
+    LanguageModelToolsExtensionPointHandler.ID,
+    LanguageModelToolsExtensionPointHandler,
+    WorkbenchPhase.BlockRestore
+);
+registerWorkbenchContribution2(
+    ChatPromptFilesExtensionPointHandler.ID,
+    ChatPromptFilesExtensionPointHandler,
+    WorkbenchPhase.BlockRestore
+);
+registerWorkbenchContribution2(
+    ChatCompatibilityNotifier.ID,
+    ChatCompatibilityNotifier,
+    WorkbenchPhase.Eventually
+);
+registerWorkbenchContribution2(
+    CodeBlockActionRendering.ID,
+    CodeBlockActionRendering,
+    WorkbenchPhase.BlockRestore
+);
+registerWorkbenchContribution2(
+    ChatCopyActionRendering.ID,
+    ChatCopyActionRendering,
+    WorkbenchPhase.BlockRestore
+);
+registerWorkbenchContribution2(
+    ChatImplicitContextContribution.ID,
+    ChatImplicitContextContribution,
+    WorkbenchPhase.Eventually
+);
+registerWorkbenchContribution2(
+    ChatViewsWelcomeHandler.ID,
+    ChatViewsWelcomeHandler,
+    WorkbenchPhase.BlockStartup
+);
+registerWorkbenchContribution2(
+    ChatGettingStartedContribution.ID,
+    ChatGettingStartedContribution,
+    WorkbenchPhase.Eventually
+);
+registerWorkbenchContribution2(
+    ChatSetupContribution.ID,
+    ChatSetupContribution,
+    WorkbenchPhase.BlockRestore
+);
+registerWorkbenchContribution2(
+    HasByokModelsContribution.ID,
+    HasByokModelsContribution,
+    WorkbenchPhase.BlockRestore
+);
+registerWorkbenchContribution2(
+    ChatTeardownContribution.ID,
+    ChatTeardownContribution,
+    WorkbenchPhase.AfterRestored
+);
+registerWorkbenchContribution2(ChatStatusBarEntry.ID, ChatStatusBarEntry, WorkbenchPhase.BlockRestore);
+registerWorkbenchContribution2(
+    BuiltinToolsContribution.ID,
+    BuiltinToolsContribution,
+    WorkbenchPhase.Eventually
+);
+registerWorkbenchContribution2(
+    UsagesToolContribution.ID,
+    UsagesToolContribution,
+    WorkbenchPhase.BlockRestore
+);
+registerWorkbenchContribution2(
+    RenameToolContribution.ID,
+    RenameToolContribution,
+    WorkbenchPhase.BlockRestore
+);
+registerWorkbenchContribution2(
+    ChatAgentSettingContribution.ID,
+    ChatAgentSettingContribution,
+    WorkbenchPhase.AfterRestored
+);
+registerWorkbenchContribution2(
+    ChatForegroundSessionCountContribution.ID,
+    ChatForegroundSessionCountContribution,
+    WorkbenchPhase.AfterRestored
+);
+registerWorkbenchContribution2(
+    ChatAgentActionsContribution.ID,
+    ChatAgentActionsContribution,
+    WorkbenchPhase.Eventually
+);
+registerWorkbenchContribution2(
+    HookSchemaAssociationContribution.ID,
+    HookSchemaAssociationContribution,
+    WorkbenchPhase.AfterRestored
+);
+registerWorkbenchContribution2(
+    ToolReferenceNamesContribution.ID,
+    ToolReferenceNamesContribution,
+    WorkbenchPhase.AfterRestored
+);
+registerWorkbenchContribution2(
+    ChatAgentRecommendation.ID,
+    ChatAgentRecommendation,
+    WorkbenchPhase.Eventually
+);
+registerWorkbenchContribution2(
+    ChatEditingEditorAccessibility.ID,
+    ChatEditingEditorAccessibility,
+    WorkbenchPhase.AfterRestored
+);
+registerWorkbenchContribution2(
+    ChatQueuePickerRendering.ID,
+    ChatQueuePickerRendering,
+    WorkbenchPhase.BlockRestore
+);
+registerWorkbenchContribution2(
+    ChatEditingEditorOverlay.ID,
+    ChatEditingEditorOverlay,
+    WorkbenchPhase.AfterRestored
+);
+registerWorkbenchContribution2(
+    ChatEditingEditorContextKeys.ID,
+    ChatEditingEditorContextKeys,
+    WorkbenchPhase.AfterRestored
+);
+registerWorkbenchContribution2(
+    ChatTransferContribution.ID,
+    ChatTransferContribution,
+    WorkbenchPhase.BlockRestore
+);
+registerWorkbenchContribution2(
+    ChatContextContributions.ID,
+    ChatContextContributions,
+    WorkbenchPhase.AfterRestored
+);
+registerWorkbenchContribution2(PromptUrlHandler.ID, PromptUrlHandler, WorkbenchPhase.BlockRestore);
+registerWorkbenchContribution2(PluginUrlHandler.ID, PluginUrlHandler, WorkbenchPhase.BlockRestore);
+registerWorkbenchContribution2(
+    ChatEditingNotebookFileSystemProviderContrib.ID,
+    ChatEditingNotebookFileSystemProviderContrib,
+    WorkbenchPhase.BlockStartup
+);
+registerWorkbenchContribution2(
+    ChatResponseResourceWorkbenchContribution.ID,
+    ChatResponseResourceWorkbenchContribution,
+    WorkbenchPhase.AfterRestored
+);
+registerWorkbenchContribution2(
+    UserToolSetsContributions.ID,
+    UserToolSetsContributions,
+    WorkbenchPhase.Eventually
+);
+registerWorkbenchContribution2(
+    PromptLanguageFeaturesProvider.ID,
+    PromptLanguageFeaturesProvider,
+    WorkbenchPhase.Eventually
+);
+registerWorkbenchContribution2(ChatWindowNotifier.ID, ChatWindowNotifier, WorkbenchPhase.AfterRestored);
+registerWorkbenchContribution2(
+    ChatRepoInfoContribution.ID,
+    ChatRepoInfoContribution,
+    WorkbenchPhase.Eventually
+);
+registerWorkbenchContribution2(
+    AgentPluginRecommendations.ID,
+    AgentPluginRecommendations,
+    WorkbenchPhase.Eventually
+);
+registerWorkbenchContribution2(PluginAutoUpdate.ID, PluginAutoUpdate, WorkbenchPhase.Eventually);
+registerChatActions();
+registerChatAccessibilityActions();
+registerChatCopyActions();
+registerChatOpenAgentDebugPanelAction();
+registerChatCodeBlockActions();
+registerChatCodeCompareBlockActions();
+registerChatFileTreeActions();
+registerChatPromptNavigationActions();
+registerChatTitleActions();
+registerChatExecuteActions();
+registerChatQueueActions();
+registerQuickChatActions();
+registerChatExportActions();
+registerMoveActions();
+registerNewChatActions();
+registerChatContextActions();
+registerChatDeveloperActions();
+registerChatEditorActions();
+registerChatElicitationActions();
+registerChatToolActions();
+registerLanguageModelActions();
+registerChatPluginActions();
+registerPlanReviewFeedbackEditorActions();
+registerAction2(ConfigureToolSets);
+registerEditorFeature(ChatPasteProvidersFeature);
+agentPluginDiscoveryRegistry.register(( new SyncDescriptor(ConfiguredAgentPluginDiscovery)));
+agentPluginDiscoveryRegistry.register(( new SyncDescriptor(MarketplaceAgentPluginDiscovery)));
+agentPluginDiscoveryRegistry.register(( new SyncDescriptor(ExtensionAgentPluginDiscovery)));
+agentPluginDiscoveryRegistry.register(( new SyncDescriptor(CopilotCliAgentPluginDiscovery)));
+ChatWidget.CONTRIBS.push(ChatDynamicVariableModel);