@codingame/monaco-vscode-api 36.2.7 → 37.1.0

package/vscode/src/vs/workbench/contrib/chat/common/constants.js

@@ -1,13 +1,18 @@
 
 import { Schemas } from '../../../../base/common/network.js';
-import { SessionType, localChatSessionType } from './chatSessionsService.js';
+import { localChatSessionType, SessionType, isAgentHostTarget } from './chatSessionsService.js';
 import { IChatSessionsService } from './chatSessionsService.service.js';
+import { IConfigurationService } from '../../../../platform/configuration/common/configuration.service.js';
+import { IStorageService } from '../../../../platform/storage/common/storage.service.js';
+import { IWorkspaceContextService } from '../../../../platform/workspace/common/workspace.service.js';
+import { isVirtualWorkspace } from '../../../../platform/workspace/common/virtualWorkspace.js';
 import { ContextKeyExpr, RawContextKey } from '../../../../platform/contextkey/common/contextkey.js';
 import { ChatEntitlementContextKeys } from '../../../services/chat/common/chatEntitlementService.js';
 import { IsSessionsWindowContext, IsAuxiliaryWindowContext } from '../../../common/contextkeys.js';
-import { URI } from '../../../../base/common/uri.js';
-import { generateUuid } from '../../../../base/common/uuid.js';
-import { LocalChatSessionUri } from './model/chatUri.js';
+import './model/chatUri.js';
+import { getRememberedSessionType, clearUserSelectedSessionType, storeUserSelectedSessionType } from './chatSessionTypePreference.js';
+import { IAgentHostEnablementService } from '../../../../platform/agentHost/common/agentHostEnablementService.service.js';
+export { ChatAIDisabledSettingId } from '../../../../platform/chat/common/chatSettings.js';
 
 var BYOKUtilityModelDefault;
 (function(BYOKUtilityModelDefault) {
@@ -15,9 +20,14 @@ var BYOKUtilityModelDefault;
     BYOKUtilityModelDefault["MainAgent"] = "mainAgent";
     BYOKUtilityModelDefault["Copilot"] = "copilot";
 })(BYOKUtilityModelDefault || (BYOKUtilityModelDefault = {}));
+var CustomizationMigrationHintMode;
+(function(CustomizationMigrationHintMode) {
+    CustomizationMigrationHintMode["Never"] = "never";
+    CustomizationMigrationHintMode["Once"] = "once";
+    CustomizationMigrationHintMode["Always"] = "always";
+})(CustomizationMigrationHintMode || (CustomizationMigrationHintMode = {}));
 var ChatConfiguration;
 (function(ChatConfiguration) {
-    ChatConfiguration["AIDisabled"] = "chat.disableAIFeatures";
     ChatConfiguration["PluginsEnabled"] = "chat.plugins.enabled";
     ChatConfiguration["PluginLocations"] = "chat.pluginLocations";
     ChatConfiguration["PluginMarketplaces"] = "chat.plugins.marketplaces";
@@ -31,13 +41,20 @@ var ChatConfiguration;
     ChatConfiguration["UtilitySmallModel"] = "chat.utilitySmallModel";
     ChatConfiguration["BYOKUtilityModelDefault"] = "chat.byokUtilityModelDefault";
     ChatConfiguration["RequestQueueingDefaultAction"] = "chat.requestQueuing.defaultAction";
+    ChatConfiguration["SaveBeforeSend"] = "chat.saveBeforeSend";
     ChatConfiguration["AgentStatusEnabled"] = "chat.agentsControl.enabled";
     ChatConfiguration["EditorAssociations"] = "chat.editorAssociations";
     ChatConfiguration["UnifiedAgentsBar"] = "chat.unifiedAgentsBar.enabled";
     ChatConfiguration["AgentSessionProjectionEnabled"] = "chat.agentSessionProjection.enabled";
+    ChatConfiguration["MigrateLegacyCopilotCliSessions"] = "chat.agentSessions.migrateLegacyCopilotCli";
+    ChatConfiguration["ShowExternalAgentSessions"] = "chat.agentSessions.showExternal";
+    ChatConfiguration["UnifiedWorkspacePicker"] = "sessions.chat.unifiedWorkspacePicker.enabled";
+    ChatConfiguration["AutoArchiveMergedSessionsAfterDays"] = "chat.agentSessions.autoArchiveMergedSessionsAfterDays";
+    ChatConfiguration["AutoDeleteArchivedMergedSessionsAfterDays"] = "chat.agentSessions.autoDeleteArchivedMergedSessionsAfterDays";
     ChatConfiguration["ExtensionToolsEnabled"] = "chat.extensionTools.enabled";
     ChatConfiguration["RepoInfoEnabled"] = "chat.repoInfo.enabled";
     ChatConfiguration["EditRequests"] = "chat.editRequests";
+    ChatConfiguration["PasteAsAttachmentThreshold"] = "chat.pasteAsAttachmentThreshold";
     ChatConfiguration["InlineReferencesStyle"] = "chat.inlineReferences.style";
     ChatConfiguration["AutoReply"] = "chat.autoReply";
     ChatConfiguration["GlobalAutoApprove"] = "chat.tools.global.autoApprove";
@@ -49,6 +66,9 @@ var ChatConfiguration;
     ChatConfiguration["ThinkingStyle"] = "chat.agent.thinkingStyle";
     ChatConfiguration["ThinkingGenerateTitles"] = "chat.agent.thinking.generateTitles";
     ChatConfiguration["TerminalToolsInThinking"] = "chat.agent.thinking.terminalTools";
+    ChatConfiguration["TerminalAgentHostEnabled"] = "chat.terminal.agentHost.enabled";
+    ChatConfiguration["InlineChatAgentHostEnabled"] = "chat.inlineChat.agentHost.enabled";
+    ChatConfiguration["CollapseCompletedResponses"] = "chat.agent.collapseCompletedResponses";
     ChatConfiguration["SimpleTerminalCollapsible"] = "chat.tools.terminal.simpleCollapsible";
     ChatConfiguration["CompressOutputEnabled"] = "chat.tools.compressOutput.enabled";
     ChatConfiguration["ThinkingPhrases"] = "chat.agent.thinking.phrases";
@@ -63,11 +83,14 @@ var ChatConfiguration;
     ChatConfiguration["ChatViewSessionsOrientation"] = "chat.viewSessions.orientation";
     ChatConfiguration["ChatViewProgressBadgeEnabled"] = "chat.viewProgressBadge.enabled";
     ChatConfiguration["ChatContextUsageEnabled"] = "chat.contextUsage.enabled";
-    ChatConfiguration["ChatPersistentProgressEnabled"] = "chat.persistentProgress.enabled";
+    ChatConfiguration["Verbose"] = "chat.verbose";
     ChatConfiguration["ProgressBorder"] = "chat.progressBorder.enabled";
+    ChatConfiguration["SessionStateIndicatorEnabled"] = "chat.experimental.sessionStateIndicator.enabled";
     ChatConfiguration["SubagentToolCustomAgents"] = "chat.customAgentInSubagent.enabled";
-    ChatConfiguration["GeneralPurposeAgentEnabled"] = "chat.generalPurposeAgent.enabled";
     ChatConfiguration["SubagentsAllowInvocationsFromSubagents"] = "chat.subagents.allowInvocationsFromSubagents";
+    ChatConfiguration["SubagentsDefaultToAuto"] = "chat.subagents.defaultToAuto";
+    ChatConfiguration["SubagentsUseRichRendering"] = "chat.subagents.useRichRendering";
+    ChatConfiguration["SubagentsShowCreditUsage"] = "chat.subagents.showCreditUsage";
     ChatConfiguration["ShowCodeBlockProgressAnimation"] = "chat.agent.codeBlockProgress";
     ChatConfiguration["RestoreLastPanelSession"] = "chat.restoreLastPanelSession";
     ChatConfiguration["ExitAfterDelegation"] = "chat.exitAfterDelegation";
@@ -77,11 +100,18 @@ var ChatConfiguration;
     ChatConfiguration["GrowthNotificationEnabled"] = "chat.growthNotification.enabled";
     ChatConfiguration["TitleBarSignInEnabled"] = "chat.titleBar.signIn.enabled";
     ChatConfiguration["TitleBarOpenInAgentsWindowEnabled"] = "chat.titleBar.openInAgentsWindow.enabled";
+    ChatConfiguration["OpenInAgentsWindowRevealCurrentSession"] = "chat.experimental.openInAgentsWindow.revealCurrentSession";
     ChatConfiguration["ChatCustomizationsStructuredPreviewEnabled"] = "chat.customizations.structuredPreview.enabled";
+    ChatConfiguration["ChatCustomizationsPromptMigrationEnabled"] = "chat.customizations.promptMigration.enabled";
+    ChatConfiguration["ChatCustomizationsUserDataMigrationEnabled"] = "chat.customizations.userDataMigration.enabled";
+    ChatConfiguration["ChatCustomizationsLocationsMigrationEnabled"] = "chat.customizations.locationsMigration.enabled";
+    ChatConfiguration["ChatCustomizationsMcpServerMigrationEnabled"] = "chat.customizations.mcpServerMigration.enabled";
+    ChatConfiguration["ChatCustomizationsMigrationHint"] = "chat.customizations.migrationHint";
     ChatConfiguration["AutopilotAdvancedEnabled"] = "chat.autopilot.advanced.enabled";
-    ChatConfiguration["PlanReviewInlineEditorEnabled"] = "chat.planReview.inlineEditor.enabled";
     ChatConfiguration["DefaultPermissionLevel"] = "chat.permissions.default";
+    ChatConfiguration["AssistedPermissionsEnabled"] = "chat.assistedPermissions.enabled";
     ChatConfiguration["PermissionsSandboxToggleEnabled"] = "chat.experimental.permissionsSandboxToggle.enabled";
+    ChatConfiguration["ExperimentalModePermissionsPicker"] = "chat.experimentalModePermissionsPicker";
     ChatConfiguration["DefaultConfiguration"] = "chat.defaultConfiguration";
     ChatConfiguration["DefaultModel"] = "chat.defaultModel";
     ChatConfiguration["ImageCarouselEnabled"] = "imageCarousel.chat.enabled";
@@ -93,18 +123,19 @@ var ChatConfiguration;
     ChatConfiguration["ToolRiskAssessmentEnabled"] = "chat.tools.riskAssessment.enabled";
     ChatConfiguration["ToolRiskAssessmentModel"] = "chat.tools.riskAssessment.model";
     ChatConfiguration["DefaultNewSessionMode"] = "chat.newSession.defaultMode";
-    ChatConfiguration["CopilotCliHideExtensionHostAgents"] = "chat.agents.copilotCli.hideExtensionHost";
-    ChatConfiguration["EditorDefaultProvider"] = "chat.editor.defaultProvider";
+    ChatConfiguration["EditorPreferCopilotHarness"] = "chat.editor.preferCopilotHarness";
+    ChatConfiguration["DefaultToCopilotHarness"] = "chat.defaultToCopilotHarness";
     ChatConfiguration["EditorLocalAgentEnabled"] = "chat.editor.localAgent.enabled";
-    ChatConfiguration["CopilotCliHideExtensionHostEditor"] = "chat.editor.copilotCli.hideExtensionHost";
     ChatConfiguration["AgentsHandoffTipMode"] = "chat.agentsHandoffTip.mode";
-    ChatConfiguration["TurnStatusPills"] = "chat.turnStatusPills";
     ChatConfiguration["IncrementalRendering"] = "chat.experimental.incrementalRendering.enabled";
     ChatConfiguration["IncrementalRenderingStyle"] = "chat.experimental.incrementalRendering.animationStyle";
     ChatConfiguration["IncrementalRenderingBuffering"] = "chat.experimental.incrementalRendering.buffering";
+    ChatConfiguration["ExperimentalStickyScrollEnabled"] = "chat.experimental.stickyScroll.enabled";
+    ChatConfiguration["RichLinks"] = "chat.experimental.richLinks.enabled";
     ChatConfiguration["CollectInstructionsInExtension"] = "chat.experimental.collectInstructionsInExtension";
     ChatConfiguration["ImplicitContextActiveEditor"] = "chat.implicitContext.includeActiveEditor";
 })(ChatConfiguration || (ChatConfiguration = {}));
+const AGENT_SESSION_CLEANUP_SETTINGS_TAG = "agentSessionCleanup";
 var ChatModeKind;
 (function(ChatModeKind) {
     ChatModeKind["Ask"] = "ask";
@@ -114,6 +145,7 @@ var ChatModeKind;
 var ChatPermissionLevel;
 (function(ChatPermissionLevel) {
     ChatPermissionLevel["Default"] = "default";
+    ChatPermissionLevel["Assisted"] = "assisted";
     ChatPermissionLevel["AutoApprove"] = "autoApprove";
     ChatPermissionLevel["Autopilot"] = "autopilot";
 })(ChatPermissionLevel || (ChatPermissionLevel = {}));
@@ -121,6 +153,26 @@ const chatPermissionLevels = ( new Set(( Object.values(ChatPermissionLevel))));
 function isChatPermissionLevel(level) {
     return ( chatPermissionLevels.has(level));
 }
+var ChatDefaultPermissionLevel;
+(function(ChatDefaultPermissionLevel) {
+    ChatDefaultPermissionLevel["Manual"] = "manual";
+    ChatDefaultPermissionLevel["Assisted"] = "assisted";
+    ChatDefaultPermissionLevel["AllowAll"] = "allowAll";
+})(ChatDefaultPermissionLevel || (ChatDefaultPermissionLevel = {}));
+function getChatPermissionLevelFromDefaultConfiguration(value) {
+    switch (value) {
+    case ChatDefaultPermissionLevel.Manual:
+    case ChatPermissionLevel.Default:
+        return ChatPermissionLevel.Default;
+    case ChatDefaultPermissionLevel.Assisted:
+        return ChatPermissionLevel.Assisted;
+    case ChatDefaultPermissionLevel.AllowAll:
+    case ChatPermissionLevel.AutoApprove:
+        return ChatPermissionLevel.AutoApprove;
+    default:
+        return undefined;
+    }
+}
 function isAutoApproveLevel(level) {
     return level === ChatPermissionLevel.AutoApprove || level === ChatPermissionLevel.Autopilot;
 }
@@ -170,6 +222,7 @@ var ChatAgentLocation;
 })(ChatAgentLocation || (ChatAgentLocation = {}));
 const chatAlwaysUnsupportedFileSchemes = ( new Set([
     Schemas.vscodeChatEditor,
+    Schemas.vscodeChatResponseResource,
     Schemas.walkThrough,
     Schemas.vscodeLocalChatSession,
     Schemas.vscodeSettings,
@@ -179,6 +232,10 @@ const chatAlwaysUnsupportedFileSchemes = ( new Set([
     "ccreq",
     "openai-codex"
 ]));
+const chatInputSchemes = [Schemas.vscodeChatInput, Schemas.sessionsChatInput];
+function isChatInputModel(uri) {
+    return chatInputSchemes.includes(uri.scheme);
+}
 function isSupportedChatFileScheme(accessor, scheme) {
     const chatService = accessor.get(IChatSessionsService);
     if (( chatAlwaysUnsupportedFileSchemes.has(scheme))) {
@@ -189,70 +246,249 @@ function isSupportedChatFileScheme(accessor, scheme) {
     }
     return true;
 }
-function getDefaultNewChatSessionType(configurationService, chatSessionsService) {
-    const defaultProvider = configurationService.getValue(ChatConfiguration.EditorDefaultProvider);
-    const defaultType = getConfiguredEditorDefaultSessionType(defaultProvider);
-    if (defaultType === SessionType.AgentHostCopilot && !isEditorLocalAgentEnabled(configurationService)) {
-        return defaultType;
+function getComputedDefaultSessionType(
+    configurationService,
+    chatSessionsService,
+    workspace,
+    agentHostEnabled,
+    managedSandboxEnforced = false
+) {
+    if (isVirtualWorkspace(workspace)) {
+        return localChatSessionType;
     }
-    if (defaultType && isVisibleEditorChatSessionType(defaultType, configurationService, chatSessionsService)) {
-        return defaultType;
+    if (agentHostEnabled && isCopilotHarnessDefault(configurationService, managedSandboxEnforced)) {
+        return SessionType.AgentHostCopilot;
     }
-    if (isEditorLocalAgentEnabled(configurationService)) {
+    if (isEditorLocalAgentEnabled(
+        configurationService,
+        workspace,
+        agentHostEnabled && managedSandboxEnforced
+    )) {
         return localChatSessionType;
     }
-    return getVisibleNonLocalEditorChatSessionTypes(configurationService, chatSessionsService)[0] ?? localChatSessionType;
+    return getVisibleNonLocalEditorChatSessionTypes(configurationService, chatSessionsService, workspace)[0] ?? localChatSessionType;
 }
-function getDefaultNewChatSessionResource(configurationService, chatSessionsService) {
-    const defaultType = getDefaultNewChatSessionType(configurationService, chatSessionsService);
-    return defaultType === localChatSessionType ? LocalChatSessionUri.getNewSessionUri() : ( URI.from({
-        scheme: defaultType,
-        path: `/untitled-${generateUuid()}`
-    }));
+function isNewChatSessionTypeUsable(
+    sessionType,
+    configurationService,
+    chatSessionsService,
+    workspace,
+    agentHostEnabled = true,
+    managedSandboxEnforced = false
+) {
+    if (sessionType === localChatSessionType) {
+        return isEditorLocalAgentEnabled(
+            configurationService,
+            workspace,
+            agentHostEnabled && managedSandboxEnforced
+        );
+    }
+    if (isAgentHostTarget(sessionType)) {
+        return agentHostEnabled;
+    }
+    return isVisibleEditorChatSessionType(
+        sessionType,
+        configurationService,
+        chatSessionsService,
+        workspace,
+        managedSandboxEnforced
+    );
+}
+function getLocalFallbackSessionTypeSelectionReason(sessionType, didAcquireSession, inheritedReason) {
+    return !didAcquireSession && isAgentHostTarget(sessionType) ? "agentHostUnavailable" : inheritedReason;
+}
+function getDefaultNewChatSessionType(
+    configurationService,
+    chatSessionsService,
+    storageService,
+    workspace,
+    agentHostEnabled,
+    options,
+    managedSandboxEnforced = false
+) {
+    return getDefaultNewChatSessionTypeAndReasonFromServices(
+        configurationService,
+        chatSessionsService,
+        storageService,
+        workspace,
+        agentHostEnabled,
+        options,
+        managedSandboxEnforced
+    ).sessionType;
+}
+function getDefaultNewChatSessionTypeAndReasonFromServices(
+    configurationService,
+    chatSessionsService,
+    storageService,
+    workspace,
+    agentHostEnabled,
+    options,
+    managedSandboxEnforced = false
+) {
+    if (options?.explicitOverride) {
+        return {
+            sessionType: options.explicitOverride,
+            selectionReason: "explicitOverride"
+        };
+    }
+    if (isVirtualWorkspace(workspace)) {
+        return {
+            sessionType: localChatSessionType,
+            selectionReason: "virtualWorkspace"
+        };
+    }
+    const preferCopilotHarness = agentHostEnabled && isCopilotHarnessPreferred(configurationService, managedSandboxEnforced);
+    const remembered = getUsableRememberedSessionType(
+        storageService,
+        configurationService,
+        chatSessionsService,
+        workspace,
+        agentHostEnabled,
+        managedSandboxEnforced
+    );
+    if (remembered && (remembered !== localChatSessionType || !preferCopilotHarness)) {
+        return {
+            sessionType: remembered,
+            selectionReason: "rememberedSelection"
+        };
+    }
+    let resolved;
+    if (options?.currentSessionType && isNewChatSessionTypeUsable(
+        options.currentSessionType,
+        configurationService,
+        chatSessionsService,
+        workspace,
+        agentHostEnabled,
+        managedSandboxEnforced
+    )) {
+        resolved = {
+            sessionType: options.currentSessionType,
+            selectionReason: "currentSession"
+        };
+    } else if (remembered) {
+        resolved = {
+            sessionType: remembered,
+            selectionReason: "rememberedSelection"
+        };
+    } else {
+        resolved = {
+            sessionType: getComputedDefaultSessionType(
+                configurationService,
+                chatSessionsService,
+                workspace,
+                agentHostEnabled,
+                managedSandboxEnforced
+            ),
+            selectionReason: "computedDefault"
+        };
+    }
+    return resolved.sessionType === localChatSessionType && preferCopilotHarness ? {
+        sessionType: SessionType.AgentHostCopilot,
+        selectionReason: "copilotPreference"
+    } : resolved;
 }
-function isEditorLocalAgentEnabled(configurationService) {
+function getDefaultNewChatSessionTypeAndReason(accessor, options) {
+    const configurationService = accessor.get(IConfigurationService);
+    const chatSessionsService = accessor.get(IChatSessionsService);
+    const storageService = accessor.get(IStorageService);
+    const workspace = accessor.get(IWorkspaceContextService).getWorkspace();
+    const agentHostEnablementService = accessor.get(IAgentHostEnablementService);
+    const agentHostEnabled = agentHostEnablementService.enabled.get();
+    const managedSandboxEnforced = agentHostEnablementService.managedSandboxEnforced.get();
+    return getDefaultNewChatSessionTypeAndReasonFromServices(
+        configurationService,
+        chatSessionsService,
+        storageService,
+        workspace,
+        agentHostEnabled,
+        options,
+        managedSandboxEnforced
+    );
+}
+function getUsableRememberedSessionType(
+    storageService,
+    configurationService,
+    chatSessionsService,
+    workspace,
+    agentHostEnabled,
+    managedSandboxEnforced = false
+) {
+    const remembered = getRememberedSessionType(storageService);
+    return remembered && isNewChatSessionTypeUsable(
+        remembered,
+        configurationService,
+        chatSessionsService,
+        workspace,
+        agentHostEnabled,
+        managedSandboxEnforced
+    ) ? remembered : undefined;
+}
+function recordUserSelectedSessionType(
+    storageService,
+    configurationService,
+    chatSessionsService,
+    workspace,
+    sessionType,
+    agentHostEnabled
+) {
+    if (sessionType === getComputedDefaultSessionType(configurationService, chatSessionsService, workspace, agentHostEnabled)) {
+        clearUserSelectedSessionType(storageService);
+    } else {
+        storeUserSelectedSessionType(storageService, sessionType);
+    }
+}
+function isCopilotHarnessDefault(configurationService, managedSandboxEnforced = false) {
+    return configurationService.getValue(ChatConfiguration.DefaultToCopilotHarness) === true || managedSandboxEnforced;
+}
+function isCopilotHarnessPreferred(configurationService, managedSandboxEnforced = false) {
+    return configurationService.getValue(ChatConfiguration.EditorPreferCopilotHarness) === true || managedSandboxEnforced;
+}
+function isEditorLocalAgentEnabled(configurationService, workspace, managedSandboxEnforced = false) {
+    if (isVirtualWorkspace(workspace)) {
+        return true;
+    }
+    if (managedSandboxEnforced) {
+        return false;
+    }
     return configurationService.getValue(ChatConfiguration.EditorLocalAgentEnabled) ?? true;
 }
-function isVisibleEditorChatSessionType(sessionType, configurationService, chatSessionsService) {
+function isVisibleEditorChatSessionType(
+    sessionType,
+    configurationService,
+    chatSessionsService,
+    workspace,
+    managedSandboxEnforced = false,
+    agentHostEnabled = true
+) {
     if (sessionType === localChatSessionType) {
-        if (!isEditorLocalAgentEnabled(configurationService) && configurationService.getValue(ChatConfiguration.EditorDefaultProvider) === "copilotAh") {
-            return false;
-        }
-        return isEditorLocalAgentEnabled(configurationService) || getVisibleNonLocalEditorChatSessionTypes(configurationService, chatSessionsService).length === 0;
+        return isEditorLocalAgentEnabled(
+            configurationService,
+            workspace,
+            agentHostEnabled && managedSandboxEnforced
+        ) || getVisibleNonLocalEditorChatSessionTypes(configurationService, chatSessionsService, workspace).length === 0;
     }
-    if (sessionType === SessionType.CopilotCLI && configurationService.getValue(ChatConfiguration.CopilotCliHideExtensionHostEditor)) {
+    if (sessionType === SessionType.CopilotCLI) {
         return false;
     }
     return !!chatSessionsService.getChatSessionContribution(sessionType);
 }
-function getConfiguredEditorDefaultSessionType(defaultProvider) {
-    switch (defaultProvider) {
-    case "local":
-        return localChatSessionType;
-    case "copilotAh":
-        return SessionType.AgentHostCopilot;
-    case "copilotEh":
-        return SessionType.CopilotCLI;
-    default:
-        return undefined;
-    }
-}
-function getVisibleNonLocalEditorChatSessionTypes(configurationService, chatSessionsService) {
+function getVisibleNonLocalEditorChatSessionTypes(configurationService, chatSessionsService, workspace) {
     const sessionTypes = ( new Set());
     for (const contribution of chatSessionsService.getAllChatSessionContributions()) {
-        if (contribution.type !== localChatSessionType && isVisibleEditorChatSessionType(contribution.type, configurationService, chatSessionsService)) {
+        if (contribution.type !== localChatSessionType && isVisibleEditorChatSessionType(contribution.type, configurationService, chatSessionsService, workspace)) {
             sessionTypes.add(contribution.type);
         }
     }
     return Array.from(sessionTypes);
 }
 const MANAGE_CHAT_COMMAND_ID = "workbench.action.chat.manage";
+const CHAT_OPEN_AGENT_HOST_CHAT_COMMAND_ID = "workbench.action.chat.openAgentHostChat";
+const CHAT_SUBAGENT_RESOURCE_QUERY_PARAM = "subagentChatResource";
 const OPEN_WORKSPACE_IN_AGENTS_WINDOW_COMMAND_ID = "workbench.action.openWorkspaceInAgentsWindow";
 const OPEN_AGENTS_WINDOW_COMMAND_ID = "workbench.action.openAgentsWindow";
 const OPEN_AGENTS_WINDOW_PRECONDITION = ( ContextKeyExpr.and(( ChatEntitlementContextKeys.Setup.hidden.negate()), ( ChatEntitlementContextKeys.Setup.disabledInWorkspace.negate()), ( IsSessionsWindowContext.negate()), ( ContextKeyExpr.has(`config.${ChatConfiguration.AgentEnabled}`)), ( IsAuxiliaryWindowContext.negate())));
 const ChatEditorTitleMaxLength = 30;
 const CONTEXT_MODELS_EDITOR = ( new RawContextKey("inModelsEditor", false));
 const CONTEXT_MODELS_SEARCH_FOCUS = ( new RawContextKey("inModelsSearch", false));
-const GeneralPurposeAgentName = "General Purpose";
 
-export { BYOKUtilityModelDefault, CONTEXT_MODELS_EDITOR, CONTEXT_MODELS_SEARCH_FOCUS, ChatAgentLocation, ChatConfiguration, ChatEditorTitleMaxLength, ChatModeKind, ChatNotificationMode, ChatPermissionLevel, CollapsedToolsDisplayMode, GeneralPurposeAgentName, MANAGE_CHAT_COMMAND_ID, OPEN_AGENTS_WINDOW_COMMAND_ID, OPEN_AGENTS_WINDOW_PRECONDITION, OPEN_WORKSPACE_IN_AGENTS_WINDOW_COMMAND_ID, ThinkingDisplayMode, getDefaultNewChatSessionResource, getDefaultNewChatSessionType, isAutoApproveLevel, isAutopilotLevel, isChatPermissionLevel, isEditorLocalAgentEnabled, isSupportedChatFileScheme, isVisibleEditorChatSessionType };
+export { AGENT_SESSION_CLEANUP_SETTINGS_TAG, BYOKUtilityModelDefault, CHAT_OPEN_AGENT_HOST_CHAT_COMMAND_ID, CHAT_SUBAGENT_RESOURCE_QUERY_PARAM, CONTEXT_MODELS_EDITOR, CONTEXT_MODELS_SEARCH_FOCUS, ChatAgentLocation, ChatConfiguration, ChatDefaultPermissionLevel, ChatEditorTitleMaxLength, ChatModeKind, ChatNotificationMode, ChatPermissionLevel, CollapsedToolsDisplayMode, CustomizationMigrationHintMode, MANAGE_CHAT_COMMAND_ID, OPEN_AGENTS_WINDOW_COMMAND_ID, OPEN_AGENTS_WINDOW_PRECONDITION, OPEN_WORKSPACE_IN_AGENTS_WINDOW_COMMAND_ID, ThinkingDisplayMode, chatInputSchemes, getChatPermissionLevelFromDefaultConfiguration, getComputedDefaultSessionType, getDefaultNewChatSessionType, getDefaultNewChatSessionTypeAndReason, getDefaultNewChatSessionTypeAndReasonFromServices, getLocalFallbackSessionTypeSelectionReason, isAutoApproveLevel, isAutopilotLevel, isChatInputModel, isChatPermissionLevel, isEditorLocalAgentEnabled, isNewChatSessionTypeUsable, isSupportedChatFileScheme, isVisibleEditorChatSessionType, recordUserSelectedSessionType };

package/vscode/src/vs/workbench/contrib/chat/common/contextContrib/chatContext.d.ts

@@ -1,9 +1,9 @@
 import { CancellationToken } from "../../../../../base/common/cancellation.js";
-import { ThemeIcon } from "../../../../../base/common/themables.js";
 import { URI } from "../../../../../base/common/uri.js";
 import { IMarkdownString } from "../../../../../base/common/htmlContent.js";
+import { ChatContextIconPath } from "../attachments/chatVariableEntries.js";
 export interface IChatContextItem {
-    icon?: ThemeIcon;
+    iconPath?: ChatContextIconPath;
     label?: string;
     resourceUri?: URI;
     modelDescription?: string;
@@ -22,6 +22,6 @@ export interface IChatExplicitContextProvider {
     resolveChatContext(context: IChatContextItem, token: CancellationToken): Promise<IChatContextItem>;
 }
 export interface IChatResourceContextProvider {
-    provideChatContext(resource: URI, withValue: boolean, token: CancellationToken): Promise<IChatContextItem | undefined>;
+    provideChatContext(resource: URI, withValue: boolean, viewType: string | undefined, token: CancellationToken): Promise<IChatContextItem | undefined>;
     resolveChatContext(context: IChatContextItem, token: CancellationToken): Promise<IChatContextItem>;
 }

package/vscode/src/vs/workbench/contrib/chat/common/customizationHarnessService.d.ts

@@ -3,11 +3,12 @@ import { IDisposable } from "../../../../base/common/lifecycle.js";
 import { Event } from "../../../../base/common/event.js";
 import { ThemeIcon } from "../../../../base/common/themables.js";
 import { URI } from "../../../../base/common/uri.js";
-import { AICustomizationSource, IStorageSourceFilter } from "./aiCustomizationWorkspaceService.js";
+import { AICustomizationSource } from "./aiCustomizationWorkspaceService.js";
 import { PromptsType } from "./promptSyntax/promptTypes.js";
 import { IChatPromptSlashCommand, ICustomAgent, IResolvedChatPromptSlashCommand } from "./promptSyntax/service/promptsService.js";
 import { IPromptsService } from "./promptSyntax/service/promptsService.service.js";
 import { CancellationToken } from "../../../../base/common/cancellation.js";
+import { type CustomizationDisabledReason } from "../../../../platform/agentHost/common/customizationEnablement.js";
 import { ICustomizationHarnessService } from "./customizationHarnessService.service.js";
 /**
  * Override for a management section's create-button behavior.
@@ -74,8 +75,7 @@ export interface IHarnessDescriptor {
     /**
      * Per-section overrides for the create button behavior.
      *
-     * A `commandId` entry replaces the button entirely with a command
-     * invocation (e.g. Claude hooks → `copilot.claude.hooks`).
+     * A `commandId` entry replaces the button entirely with a command invocation.
      *
      * A `rootFile` entry makes the primary button create a specific file
      * at the workspace root (e.g. Claude instructions → `CLAUDE.md`).
@@ -89,11 +89,6 @@ export interface IHarnessDescriptor {
      * When `undefined`, the harness is always available (e.g. Local).
      */
     readonly requiredAgentId?: string;
-    /**
-     * Returns the storage source filter that should be applied to customization
-     * items of the given type when this harness is active.
-     */
-    getStorageSourceFilter(type: PromptsType): IStorageSourceFilter;
     /**
      * When set, this harness is backed by an extension-contributed provider
      * that can supply customization items directly (bypassing promptsService
@@ -119,6 +114,12 @@ export interface IHarnessDescriptor {
      * a remote agent host). The create action remains a separate toolbar button.
      */
     readonly pluginActions?: readonly ICustomizationItemAction[];
+    /**
+     * Local MCP collection identifiers that do not apply to this harness.
+     * Host-published MCP servers remain visible even when their local counterpart
+     * belongs to a hidden collection.
+     */
+    readonly hiddenMcpServerCollectionIds?: readonly string[];
 }
 /**
  * Represents a customization item provided by any source.
@@ -144,6 +145,8 @@ export interface ICustomizationItem {
     readonly statusMessage?: string;
     /** Whether this customization is currently enabled. */
     readonly enabled?: boolean;
+    /** Host-published reason for a disabled customization. */
+    readonly disabledReason?: CustomizationDisabledReason;
     /** When set, items with the same groupKey are displayed under a shared collapsible header. */
     readonly groupKey?: string;
     /** When set, shows a small inline badge next to the item name (e.g. an applyTo glob pattern). */
@@ -169,6 +172,7 @@ export interface ICustomizationAgentRef {
 export declare function isPluginCustomizationItem(item: {
     readonly type: string;
 }): boolean;
+export declare function getCustomizationDisabledLabel(reason: CustomizationDisabledReason | undefined): string;
 /**
  * Provider interface for extension-contributed harnesses that supply
  * customization items directly from their SDK.
@@ -214,6 +218,10 @@ export interface ICustomizationSourceFolder {
     readonly uri: URI;
     /** Display label for the picker when multiple folders are offered. */
     readonly label: string;
+    /** Customization source for this folder (typically 'local' or 'user' for writable creation locations). */
+    readonly source: AICustomizationSource;
+    /** Opaque provider-defined identity shared by folders that belong to the same destination. */
+    readonly destinationGroupId?: string;
 }
 /**
  * Provider interface for harnesses that use an opt-out sync model.

package/vscode/src/vs/workbench/contrib/chat/common/customizationHarnessService.js

@@ -5,7 +5,7 @@ import { Emitter } from '../../../../base/common/event.js';
 import { ThemeIcon } from '../../../../base/common/themables.js';
 import { URI } from '../../../../base/common/uri.js';
 import { localize } from '../../../../nls.js';
-import { AICustomizationManagementSection, AICustomizationSources, BUILTIN_STORAGE } from './aiCustomizationWorkspaceService.js';
+import { AICustomizationManagementSection, BUILTIN_STORAGE } from './aiCustomizationWorkspaceService.js';
 import { PromptsType } from './promptSyntax/promptTypes.js';
 import { AGENT_MD_FILENAME } from './promptSyntax/config/promptFileLocations.js';
 import { matchesSessionType, PromptsStorage } from './promptSyntax/service/promptsService.js';
@@ -14,35 +14,50 @@ import { CustomAgent } from './promptSyntax/service/promptsServiceImpl.js';
 import { ExtensionIdentifier } from '../../../../platform/extensions/common/extensions.js';
 import { getCanonicalPluginCommandId } from './plugins/agentPluginService.js';
 import { getChatSessionType, LocalChatSessionUri } from './model/chatUri.js';
+import { isAgentBuiltinCustomizationUri } from '../../../../platform/agentHost/common/agentHostCustomizationUri.js';
+import '../../../../platform/agentHost/common/state/protocol/channels-root/state.js';
+import { CustomizationEnablementKind } from '../../../../platform/agentHost/common/state/protocol/channels-session/state.js';
+import '../../../../platform/agentHost/common/state/protocol/channels-chat/state.js';
+import '../../../../platform/agentHost/common/state/protocol/channels-terminal/state.js';
+import '../../../../platform/agentHost/common/state/protocol/channels-changeset/state.js';
+import '../../../../platform/agentHost/common/state/protocol/channels-resource-watch/state.js';
+import '../../../../platform/agentHost/common/state/protocol/channels-automation/state.js';
+import '../../../../platform/agentHost/common/state/protocol/channels-automation-run/state.js';
 import { observableValue } from '../../../../base/common/observableInternal/observables/observableValue.js';
 import { derived } from '../../../../base/common/observableInternal/observables/derived.js';
 
 function isPluginCustomizationItem(item) {
     return item.type === "plugin" || item.type === AICustomizationManagementSection.Plugins;
 }
-const EMPTY_FILTER = {
-    sources: []
-};
+function getCustomizationDisabledLabel(reason) {
+    if (reason?.source === "plugin") {
+        return localize(10443, "Disabled (Plugin)");
+    }
+    switch (reason?.scope) {
+    case CustomizationEnablementKind.Workspace:
+        return localize(10444, "Disabled (Workspace)");
+    case CustomizationEnablementKind.Session:
+        return localize(10445, "Disabled (Session)");
+    case CustomizationEnablementKind.Global:
+    case undefined:
+        return localize(10446, "Disabled");
+    }
+}
 const EMPTY_DESCRIPTOR = {
     id: "",
     label: "",
-    icon: Codicon.sparkle,
-    getStorageSourceFilter: () => EMPTY_FILTER
+    icon: Codicon.sparkle
 };
 function createVSCodeHarnessDescriptor() {
-    const filter = {
-        sources: AICustomizationSources.all
-    };
     return {
         id: SessionType.Local,
-        label: ( localize(8541, "Local")),
+        label: ( localize(10447, "Local")),
         icon: ThemeIcon.fromId(Codicon.vm.id),
         supportsTroubleshoot: true,
         hiddenSections: [AICustomizationManagementSection.Tools],
         sectionOverrides: ( new Map([[AICustomizationManagementSection.Instructions, {
             rootFileShortcuts: [AGENT_MD_FILENAME]
-        }]])),
-        getStorageSourceFilter: () => filter
+        }]]))
     };
 }
 class CustomizationHarnessServiceBase {
@@ -231,6 +246,9 @@ class CustomizationHarnessServiceBase {
         const commands = await this.getSlashCommands(sessionResource, token);
         const command = commands.find(cmd => cmd.name === name);
         if (command) {
+            if (isAgentBuiltinCustomizationUri(command.uri)) {
+                return command;
+            }
             const parsedPromptFile = await this.promptsService.parseNew(command.uri, token);
             return {
                 ...command,
@@ -251,4 +269,4 @@ class CustomizationHarnessServiceBase {
     }
 }
 
-export { CustomizationHarnessServiceBase, createVSCodeHarnessDescriptor, isPluginCustomizationItem };
+export { CustomizationHarnessServiceBase, createVSCodeHarnessDescriptor, getCustomizationDisabledLabel, isPluginCustomizationItem };