@codingame/monaco-vscode-api 37.6.1 → 38.0.1

package/vscode/src/vs/sessions/contrib/providers/agentHost/browser/agentHostSessionConfigPicker.js

@@ -0,0 +1,1816 @@
+
+import { registerCss } from '../../../../../../../../css.js';
+import { __decorate, __param } from '../../../../../../../../external/tslib/tslib.es6.js';
+import * as agentHostSessionConfigPicker from './media/agentHostSessionConfigPicker.css';
+import { getActiveElement, isHTMLElement, getActiveDocument, append, $, EventType, addDisposableListener, EventHelper, clearNode, isAncestorOfActiveElement, isAncestor, isActiveElement } from '../../../../../base/browser/dom.js';
+import { Gesture, EventType as EventType$1 } from '../../../../../base/browser/touch.js';
+import { renderIcon } from '../../../../../base/browser/ui/iconLabel/iconLabels.js';
+import { ActionListItemKind } from '../../../../../platform/actionWidget/browser/actionList.js';
+import { IActionWidgetService } from '../../../../../platform/actionWidget/browser/actionWidget.service.js';
+import { AnchorPosition } from '../../../../../base/common/layout.js';
+import { BaseActionViewItem } from '../../../../../base/browser/ui/actionbar/actionViewItems.js';
+import { Checkbox } from '../../../../../base/browser/ui/toggle/toggle.js';
+import { toAction } from '../../../../../base/common/actions.js';
+import { SequencerByKey, Delayer } from '../../../../../base/common/async.js';
+import { Codicon } from '../../../../../base/common/codicons.js';
+import { onUnexpectedError, isCancellationError } from '../../../../../base/common/errors.js';
+import { Disposable, MutableDisposable, DisposableStore, DisposableMap, toDisposable } from '../../../../../base/common/lifecycle.js';
+import '../../../../../base/common/observableInternal/index.js';
+import { ThemeIcon } from '../../../../../base/common/themables.js';
+import { localize, localize2 } from '../../../../../nls.js';
+import { IActionViewItemService } from '../../../../../platform/actions/browser/actionViewItemService.service.js';
+import { MenuId, MenuRegistry, MenuItemAction, registerAction2, Action2 } from '../../../../../platform/actions/common/actions.js';
+import { CommandsRegistry } from '../../../../../platform/commands/common/commands.js';
+import { IConfigurationService } from '../../../../../platform/configuration/common/configuration.service.js';
+import { ContextKeyExpr } from '../../../../../platform/contextkey/common/contextkey.js';
+import { IContextKeyService } from '../../../../../platform/contextkey/common/contextkey.service.js';
+import { IDialogService } from '../../../../../platform/dialogs/common/dialogs.service.js';
+import { IInstantiationService } from '../../../../../platform/instantiation/common/instantiation.js';
+import { IHoverService } from '../../../../../platform/hover/browser/hover.service.js';
+import { INotificationService } from '../../../../../platform/notification/common/notification.service.js';
+import { ITelemetryService } from '../../../../../platform/telemetry/common/telemetry.service.js';
+import { IStorageService } from '../../../../../platform/storage/common/storage.service.js';
+import { defaultCheckboxStyles } from '../../../../../platform/theme/browser/defaultStyles.js';
+import { getSessionConfigPresentationKey, getSessionApprovalProperty, getSessionWorkspaceProperties, isSessionConfigWritable, writeSessionIsolation } from '../../../../../platform/agentHost/common/sessionConfigProperties.js';
+import { IQuickInputService } from '../../../../../platform/quickinput/common/quickInput.service.js';
+import { ChatConfiguration, isChatPermissionLevel } from '../../../../../workbench/contrib/chat/common/constants.js';
+import { maybeConfirmElevatedPermissionLevel } from '../../../../../workbench/contrib/chat/common/chatPermissionWarnings.js';
+import { ChatContextKeys, ChatContextKeyExprs } from '../../../../../workbench/contrib/chat/common/actions/chatContextKeys.js';
+import { markOnboardingTarget } from '../../../../../workbench/contrib/onboarding/browser/spotlight/onboardingTarget.js';
+import { registerWorkbenchContribution2, WorkbenchPhase } from '../../../../../workbench/common/contributions.js';
+import { IViewsService } from '../../../../../workbench/services/views/common/viewsService.service.js';
+import { AgentWorkbenchLayout } from '../../../../browser/workbench.js';
+import { IAgentWorkbenchLayoutService } from '../../../../browser/workbench.service.js';
+import { Menus, getNewSessionRepositoryConfigGroup } from '../../../../browser/menus.js';
+import { DevContainerWorktreeEnabledSettingId } from '../../../../common/devContainerAgentHostService.js';
+import { SessionUsesExperimentalComposerLayoutContext, SessionProviderIdContext, IsPhoneLayoutContext, IsQuickChatSessionContext, SessionIdContext } from '../../../../common/contextkeys.js';
+import { IWorkbenchLayoutService } from '../../../../../workbench/services/layout/browser/layoutService.service.js';
+import { reportNewChatPickerClosed } from '../../../chat/browser/newChatPickerTelemetry.js';
+import { NEW_WORKTREE_LABEL } from '../../../chat/browser/branchPicker.js';
+import { EXPERIMENTAL_NEW_SESSION_COMPOSER_LAYOUT_SETTING, UNIFIED_WORKSPACE_PICKER_SETTING } from '../../../chat/common/constants.js';
+import '../../../changes/browser/sessionChangesService.js';
+import { CHANGES_VIEW_ID } from '../../../changes/common/changes.js';
+import { ISessionsProvidersService } from '../../../../services/sessions/browser/sessionsProvidersService.service.js';
+import { ISessionContext } from '../../../../services/sessions/browser/sessionContext.service.js';
+import { ISessionsService } from '../../../../services/sessions/browser/sessionsService.service.js';
+import { REMOTE_AGENT_HOST_PROVIDER_RE, LOCAL_AGENT_HOST_PROVIDER_ID, isAgentHostProvider } from '../../../../common/agentHostSessionsProvider.js';
+import { MobilePermissionPicker } from '../../copilotChatSessions/browser/mobilePermissionPicker.js';
+import { isPhoneLayout } from '../../../../browser/parts/mobile/mobileLayout.js';
+import { showMobilePickerSheet, MOBILE_PICKER_SHEET_CONFIRM } from '../../../../browser/parts/mobile/mobilePickerSheet.js';
+import { AgentHostModePicker } from './agentHostModePicker.js';
+import { MobileAgentHostModePicker } from './mobile/mobileAgentHostModePicker.js';
+import { AgentHostPermissionPickerActionItem } from './agentHostPermissionPickerActionItem.js';
+import { isWellKnownClaudePermissionModeSchema, isWellKnownCodexApprovalsSchema, AgentHostPermissionPickerDelegate } from './agentHostPermissionPickerDelegate.js';
+import { SessionConfigKey } from '../../../../../platform/agentHost/common/sessionConfigKeys.js';
+import { findDevContainerSample } from '../../../../../platform/agentHost/common/devContainerSamples.js';
+import { AGENT_HOST_CHECKOUT_CHANGESET_OPERATION_ID } from '../../../../../platform/agentHost/common/agentHostChangesetOperationService.js';
+import { checkoutOperationMeta, isCheckoutOperationDirtyWorkingTreeErrorData, CheckoutOperationPreAction } from '../../../../../platform/agentHost/common/meta/vscode/agentCheckoutOperationMeta.js';
+import { ProtocolError } from '../../../../../platform/agentHost/common/state/sessionProtocol.js';
+import { AgentHostClaudePermissionModePicker } from './agentHostClaudePermissionModePicker.js';
+import { ClaudeSessionConfigKey } from '../../../../../platform/agentHost/common/claudeSessionConfigKeys.js';
+import { AgentHostCodexApprovalsPicker } from './agentHostCodexApprovalsPicker.js';
+import { isAutoApproveValuePolicyRestricted } from '../../../../../workbench/contrib/chat/common/agentHostConfigPolicy.js';
+import { getPermissionLevelBadge, isWellKnownModeSchema } from '../../../../../workbench/contrib/chat/browser/agentSessions/agentHost/agentHostModePickerPresentation.js';
+import { ensureSelectedBranchPickerItem, BRANCH_PICKER_MAX_VISIBLE_ITEMS, filterBranchPickerItems } from '../../../../../workbench/contrib/chat/browser/agentSessions/agentHost/agentHostBranchPicker.js';
+import { CodexSessionConfigKey } from '../../../../../platform/agentHost/common/codexSessionConfigKeys.js';
+import { UNCOMMITTED_CHANGES_CHANGESET_ID } from '../../../../services/sessions/common/session.js';
+import { MarkdownString } from '../../../../../base/common/htmlContent.js';
+import { autorun } from '../../../../../base/common/observableInternal/reactions/autorun.js';
+import { observableValue } from '../../../../../base/common/observableInternal/observables/observableValue.js';
+import { ISessionChangesService } from '../../../changes/common/sessionChangesService.service.js';
+
+registerCss(agentHostSessionConfigPicker, 1);
+const ExperimentalSessionComposerLayout = SessionUsesExperimentalComposerLayoutContext;
+const LegacySessionComposerLayout = ( SessionUsesExperimentalComposerLayoutContext.negate());
+const IsActiveSessionRemoteAgentHost = ( ContextKeyExpr.regex(SessionProviderIdContext.key, REMOTE_AGENT_HOST_PROVIDER_RE));
+const IsActiveSessionLocalAgentHost = ( ContextKeyExpr.equals(SessionProviderIdContext.key, LOCAL_AGENT_HOST_PROVIDER_ID));
+const AGENT_HOST_SESSION_CONFIG_PICKER_ID_PREFIX = "sessions.agentHost.sessionConfigPicker";
+const PICKER_OPEN_ATTRIBUTE = "data-picker-open";
+const MOBILE_BRANCH_PICKER_RESULT_LIMIT = 25;
+const repositoryConfigSequencer = ( new SequencerByKey());
+function showActiveSessionModePicker(accessor) {
+    const activeElement = getActiveElement();
+    const anchor = isHTMLElement(activeElement) ? activeElement : getActiveDocument().body;
+    const picker = accessor.get(IInstantiationService).createInstance(
+        isPhoneLayout(accessor.get(IWorkbenchLayoutService)) ? MobileAgentHostModePicker : AgentHostModePicker,
+        accessor.get(ISessionsService).activeSession
+    );
+    if (!picker.showPicker(anchor, () => picker.dispose())) {
+        picker.dispose();
+    }
+}
+function getConfigIcon(property, value, hasUncommittedChanges = false) {
+    if (property === SessionConfigKey.Isolation) {
+        if (value === "folder") {
+            return Codicon.folder;
+        }
+        if (value === "worktree") {
+            return Codicon.worktree;
+        }
+    }
+    if (property === SessionConfigKey.Branch) {
+        return hasUncommittedChanges ? Codicon.gitBranchChanges : Codicon.gitBranch;
+    }
+    if (property === SessionConfigKey.AutoApprove) {
+        if (value === "autopilot") {
+            return Codicon.rocket;
+        }
+        if (value === "autoApprove") {
+            return Codicon.warning;
+        }
+        if (value === "assisted") {
+            return Codicon.sparkle;
+        }
+        return Codicon.shield;
+    }
+    return undefined;
+}
+function formatUncommittedChanges(count) {
+    return count === 1 ? ( localize(4865, "1 uncommitted file")) : ( localize(4866, "{0} uncommitted files", count));
+}
+function getBranchUncommittedChanges(branchName, repositoryBranchName, repositoryUncommittedChanges) {
+    return branchName === repositoryBranchName && (repositoryUncommittedChanges ?? 0) > 0 ? repositoryUncommittedChanges : undefined;
+}
+function toActionItems(property, items, currentValue, policyRestricted, branchContext) {
+    const query = branchContext?.query?.toLowerCase();
+    const pickerItems = property === SessionConfigKey.Branch ? ensureSelectedBranchPickerItem(items, currentValue, query) : items;
+    const actionItems = pickerItems.map(item => {
+        const policyDisabled = property === SessionConfigKey.AutoApprove && isAutoApproveValuePolicyRestricted(item.value, policyRestricted === true);
+        const disabled = item.disabled || policyDisabled;
+        const checked = isSelectedValue(currentValue, item.value);
+        const uncommittedChanges = property === SessionConfigKey.Branch ? getBranchUncommittedChanges(item.value, branchContext?.branchName, branchContext?.uncommittedChanges) : undefined;
+        const uncommittedChangesDescription = uncommittedChanges !== undefined ? formatUncommittedChanges(uncommittedChanges) : undefined;
+        const detail = policyDisabled ? ( localize(4867, "Disabled by your organization. Contact your administrator.")) : uncommittedChangesDescription ?? item.description;
+        return {
+            kind: ActionListItemKind.Action,
+            label: item.label,
+            ...(property === SessionConfigKey.AutoApprove ? getPermissionLevelBadge(item.value) : {}),
+            detail,
+            group: {
+                title: "",
+                icon: getConfigIcon(property, item.value, uncommittedChanges !== undefined)
+            },
+            ariaDescription: detail,
+            disabled,
+            item: {
+                ...item,
+                checked: property === SessionConfigKey.Branch ? undefined : checked,
+                ...(property === SessionConfigKey.Branch ? {
+                    id: item.value
+                } : {})
+            },
+            toolbarActions: property === SessionConfigKey.Branch && item.value === branchContext?.branchName && branchContext.onShowChanges ? [toAction({
+                id: "sessions.agentHost.showBranchChanges",
+                label: ( localize(4868, "Show Changes")),
+                class: ThemeIcon.asClassName(Codicon.diffMultiple),
+                run: branchContext.onShowChanges
+            })] : undefined
+        };
+    });
+    if (property === SessionConfigKey.Branch) {
+        actionItems.unshift(
+            ...takePinnedBranchItems(actionItems, getPinnedBranchGroups(currentValue, branchContext), query)
+        );
+    }
+    return actionItems;
+}
+function getPinnedBranchGroups(currentValue, branchContext) {
+    const defaultLabel = ( localize(4869, "Default Branch"));
+    const currentLabel = ( localize(4870, "Current Branch"));
+    if (!branchContext?.isWorktree) {
+        const selected = typeof currentValue === "string" ? currentValue : undefined;
+        return [{
+            label: currentLabel,
+            branches: selected !== branchContext?.defaultBranchName ? [{
+                name: selected,
+                isRemote: false
+            }] : []
+        }, {
+            label: defaultLabel,
+            branches: [{
+                name: branchContext?.defaultBranchName,
+                isRemote: false
+            }]
+        }];
+    }
+    return [{
+        label: currentLabel,
+        branches: branchContext.branchName !== branchContext.defaultBranchName ? [{
+            name: branchContext.upstreamBranchName !== branchContext.defaultRemoteBranchName ? branchContext.upstreamBranchName : undefined,
+            isRemote: true
+        }, {
+            name: branchContext.branchName,
+            isRemote: false
+        }] : []
+    }, {
+        label: defaultLabel,
+        branches: [{
+            name: branchContext.defaultRemoteBranchName,
+            isRemote: true
+        }, {
+            name: branchContext.defaultBranchName,
+            isRemote: false
+        }]
+    }];
+}
+function takePinnedBranchItems(actionItems, groups, query) {
+    const withGroupTitle = (item, title) => ({
+        ...item,
+        group: {
+            ...item.group,
+            title
+        }
+    });
+    const pinnedItems = [];
+    const pinnedNames = ( new Set());
+    for (const group of groups) {
+        const groupItems = [];
+        for (const {
+            name,
+            isRemote
+        } of group.branches) {
+            if (!name || ( pinnedNames.has(name))) {
+                continue;
+            }
+            const index = actionItems.findIndex(item => item.item?.value === name);
+            const item = index >= 0 ? actionItems.splice(index, 1)[0] : isRemote && (!query || name.toLowerCase().includes(query)) ? {
+                kind: ActionListItemKind.Action,
+                label: name,
+                group: {
+                    title: "",
+                    icon: Codicon.gitBranch
+                },
+                item: {
+                    id: name,
+                    value: name,
+                    label: name
+                }
+            } : undefined;
+            if (item) {
+                pinnedNames.add(name);
+                groupItems.push(withGroupTitle(item, group.label));
+            }
+        }
+        if (groupItems.length > 0) {
+            if (pinnedItems.length > 0) {
+                pinnedItems.push({
+                    kind: ActionListItemKind.Separator,
+                    label: group.label
+                });
+            }
+            pinnedItems.push(...groupItems);
+        }
+    }
+    if (pinnedItems.length > 0 && actionItems.length > 0) {
+        const remainingLabel = ( localize(4871, "Branches"));
+        pinnedItems.push({
+            kind: ActionListItemKind.Separator,
+            label: remainingLabel
+        });
+        for (let i = 0; i < actionItems.length; i++) {
+            actionItems[i] = withGroupTitle(actionItems[i], remainingLabel);
+        }
+    }
+    return pinnedItems;
+}
+function isSelectedValue(currentValue, itemValue) {
+    if (typeof currentValue === "boolean") {
+        return currentValue === (itemValue === "true");
+    }
+    return itemValue === currentValue;
+}
+function renderPickerTrigger(slot, disabled, disposables, onOpen) {
+    const trigger = append(slot, disabled ? $("span.action-label") : $("a.action-label"));
+    if (disabled) {
+        trigger.setAttribute("aria-readonly", "true");
+    } else {
+        trigger.role = "button";
+        trigger.tabIndex = 0;
+        trigger.setAttribute("aria-haspopup", "listbox");
+        trigger.setAttribute("aria-expanded", "false");
+        disposables.add(Gesture.addTarget(trigger));
+        for (const eventType of [EventType.CLICK, EventType$1.Tap]) {
+            disposables.add(addDisposableListener(trigger, eventType, e => {
+                EventHelper.stop(e, true);
+                onOpen();
+            }));
+        }
+        disposables.add(addDisposableListener(trigger, EventType.KEY_DOWN, e => {
+            if (e.key === "Enter" || e.key === " ") {
+                EventHelper.stop(e, true);
+                onOpen();
+            }
+        }));
+    }
+    slot.classList.toggle("disabled", disabled);
+    return trigger;
+}
+function applyAutoApproveFiltering(items, property, configurationService) {
+    if (property !== SessionConfigKey.AutoApprove) {
+        return {
+            items,
+            policyRestricted: false
+        };
+    }
+    const policyRestricted = configurationService.inspect(ChatConfiguration.GlobalAutoApprove).policyValue === false;
+    return {
+        items,
+        policyRestricted
+    };
+}
+function isRenderableSessionConfigProperty(property, schema, configSchema, isNewSession) {
+    const presentation = getSessionConfigPresentationKey(property, configSchema);
+    if (schema.type !== "boolean" && (schema.type !== "string" || (!schema.enumDynamic && !schema.enum?.length && presentation !== "newBranch"))) {
+        return false;
+    }
+    const approval = getSessionApprovalProperty(configSchema);
+    const workspace = getSessionWorkspaceProperties(configSchema);
+    if ((property === "approvalMode" && Object.hasOwn(configSchema.properties, SessionConfigKey.AutoApprove)) || ((property === "target" || property === "baseBranch") && workspace.isolationKey === SessionConfigKey.Isolation) || (schema.readOnly && ["effectiveApprovalMode", "availableApprovalModes", "effectiveAutoTier"].includes(property))) {
+        return false;
+    }
+    if (property === SessionConfigKey.SandboxEnabled) {
+        return false;
+    }
+    if (presentation === SessionConfigKey.Isolation && !schema.enum?.includes("worktree")) {
+        return false;
+    }
+    if (property === approval?.key && isSessionConfigWritable(schema, isNewSession)) {
+        return false;
+    }
+    if (property === SessionConfigKey.Mode && isWellKnownModeSchema(schema) && isSessionConfigWritable(schema, isNewSession)) {
+        return false;
+    }
+    if (property === ClaudeSessionConfigKey.PermissionMode && isWellKnownClaudePermissionModeSchema(schema)) {
+        return false;
+    }
+    if (property === CodexSessionConfigKey.PermissionsPreset && isWellKnownCodexApprovalsSchema(schema)) {
+        return false;
+    }
+    return true;
+}
+function orderSessionConfigProperties(properties, phoneLayout) {
+    const schema = {
+        properties: Object.fromEntries(properties)
+    };
+    const order = ( new Map(
+        phoneLayout ? [[SessionConfigKey.Branch, 0], [SessionConfigKey.Isolation, 1]] : [[SessionConfigKey.Isolation, 0], [SessionConfigKey.Branch, 1]]
+    ));
+    return properties.map(([key, schema], index) => ({
+        key,
+        schema,
+        index
+    })).sort((a, b) => {
+        const aRank = order.get(getSessionConfigPresentationKey(a.key, schema)) ?? Number.MAX_SAFE_INTEGER;
+        const bRank = order.get(getSessionConfigPresentationKey(b.key, schema)) ?? Number.MAX_SAFE_INTEGER;
+        return aRank - bRank || a.index - b.index;
+    }).map((
+        {
+            key,
+            schema
+        }
+    ) => [key, schema]);
+}
+async function confirmAutoApproveLevel(value, label, dialogService, storageService) {
+    if (!isChatPermissionLevel(value)) {
+        return true;
+    }
+    return maybeConfirmElevatedPermissionLevel(value, dialogService, storageService, {
+        defaultSettingKey: ChatConfiguration.DefaultConfiguration,
+        levelLabel: label
+    });
+}
+function triggerAriaLabel(title, label, isReadOnly, hasUncommittedChanges) {
+    if (hasUncommittedChanges) {
+        return isReadOnly ? ( localize(4872, "{0}: {1}, Uncommitted Files, Read-Only", title, label)) : ( localize(4873, "{0}: {1}, Uncommitted Files", title, label));
+    }
+    return isReadOnly ? ( localize(4874, "{0}: {1}, Read-Only", title, label)) : ( localize(4875, "{0}: {1}", title, label));
+}
+class ConfigCheckboxControl extends Disposable {
+    constructor(sessionId, label, className, _hoverService, onToggle, onboardingTarget) {
+        super();
+        this.sessionId = sessionId;
+        this._hoverService = _hoverService;
+        this._hover = this._register(( new MutableDisposable()));
+        this._enabled = true;
+        this.slot = $(".sessions-chat-picker-slot.sessions-chat-config-checkbox");
+        this.slot.classList.add(className);
+        this._row = append(this.slot, $(".action-label"));
+        this.checkbox = this._register(( new Checkbox(label, false, {
+            ...defaultCheckboxStyles,
+            size: 14
+        })));
+        append(this._row, this.checkbox.domNode);
+        const labelSpan = append(this._row, $("span.sessions-chat-dropdown-label"));
+        labelSpan.textContent = label;
+        if (onboardingTarget) {
+            this._register(markOnboardingTarget(this.slot, onboardingTarget));
+        }
+        this._register(this.checkbox.onChange(() => onToggle(this.checkbox.checked)));
+        this._register(Gesture.addTarget(this._row));
+        for (const eventType of [EventType.CLICK, EventType$1.Tap]) {
+            this._register(addDisposableListener(this._row, eventType, e => {
+                EventHelper.stop(e, true);
+                if (!this._enabled) {
+                    return;
+                }
+                this.checkbox.checked = !this.checkbox.checked;
+                onToggle(this.checkbox.checked);
+            }));
+        }
+    }
+    update(checked, readOnly, resolving, tooltip) {
+        this._enabled = !readOnly && !resolving;
+        this.checkbox.checked = checked;
+        if (readOnly) {
+            this.checkbox.disable();
+        } else {
+            this.checkbox.enable();
+            this.checkbox.domNode.setAttribute("aria-disabled", resolving ? "true" : "false");
+        }
+        this.slot.classList.toggle("disabled", readOnly);
+        this.slot.classList.toggle("resolving", !readOnly && resolving);
+        if (this._tooltip !== tooltip) {
+            this._tooltip = tooltip;
+            this._hover.value = tooltip ? this._hoverService.setupDelayedHover(this._row, {
+                content: tooltip
+            }) : undefined;
+        }
+    }
+    dispose() {
+        this.slot.remove();
+        super.dispose();
+    }
+}
+let AgentHostSessionConfigPicker = class AgentHostSessionConfigPicker extends Disposable {
+    constructor(
+        _session,
+        _property,
+        _actionWidgetService,
+        _configurationService,
+        _contextKeyService,
+        _dialogService,
+        _hoverService,
+        _sessionsProvidersService,
+        _telemetryService,
+        _layoutService,
+        _storageService,
+        _sessionChangesService,
+        _viewsService,
+        _notificationService,
+        _quickInputService
+    ) {
+        super();
+        this._session = _session;
+        this._property = _property;
+        this._actionWidgetService = _actionWidgetService;
+        this._configurationService = _configurationService;
+        this._contextKeyService = _contextKeyService;
+        this._dialogService = _dialogService;
+        this._hoverService = _hoverService;
+        this._sessionsProvidersService = _sessionsProvidersService;
+        this._telemetryService = _telemetryService;
+        this._layoutService = _layoutService;
+        this._storageService = _storageService;
+        this._sessionChangesService = _sessionChangesService;
+        this._viewsService = _viewsService;
+        this._notificationService = _notificationService;
+        this._quickInputService = _quickInputService;
+        this._renderDisposables = this._register(( new DisposableStore()));
+        this._providerListeners = this._register(( new DisposableMap()));
+        this._isolationCheckbox = this._register(( new MutableDisposable()));
+        this._hostMarker = this._register(( new MutableDisposable()));
+        this._filterDelayer = this._register(( new Delayer(200)));
+        this._focusable = false;
+        this._dynamicValueLabels = ( new Map());
+        this._register(autorun(reader => {
+            const session = this._session.read(reader);
+            for (const changeset of session?.activeChat.read(reader).changesets.read(reader) ?? []) {
+                changeset.operations?.read(reader);
+            }
+            this._renderConfigPickers();
+        }));
+        this._register(this._sessionsProvidersService.onDidChangeProviders(e => {
+            for (const provider of e.removed) {
+                this._providerListeners.deleteAndDispose(provider.id);
+            }
+            this._watchProviders(e.added);
+            this._renderConfigPickers();
+        }));
+        this._watchProviders(this._sessionsProvidersService.getProviders());
+        this._register(this._configurationService.onDidChangeConfiguration(e => {
+            if (e.affectsConfiguration(DevContainerWorktreeEnabledSettingId)) {
+                this._renderConfigPickers();
+            }
+        }));
+        this._register(this._contextKeyService.onDidChangeContext(e => {
+            if (e.affectsSome(( new Set([IsPhoneLayoutContext.key])))) {
+                this._renderConfigPickers();
+            }
+        }));
+        this._register(toDisposable(() => {
+            if (this._openedPickerSessionId) {
+                this._actionWidgetService.hide(true);
+            }
+        }));
+    }
+    _watchProviders(providers) {
+        for (const provider of providers) {
+            if (!isAgentHostProvider(provider) || ( this._providerListeners.has(provider.id))) {
+                continue;
+            }
+            this._providerListeners.set(
+                provider.id,
+                provider.onDidChangeSessionConfig(() => this._renderConfigPickers())
+            );
+        }
+    }
+    render(container) {
+        this._isolationCheckbox.clear();
+        container.classList.add("sessions-chat-agent-host-config-host");
+        this._hostMarker.value = toDisposable(() => container.classList.remove("sessions-chat-agent-host-config-host"));
+        this._container = append(container, $(".sessions-chat-agent-host-config"));
+        this._renderConfigPickers();
+        return this._focusableElement;
+    }
+    setFocusable(focusable) {
+        this._focusable = focusable;
+        if (this._property === undefined) {
+            return;
+        }
+        if (this._focusableElement) {
+            this._focusableElement.tabIndex = focusable ? 0 : -1;
+        }
+    }
+    focus() {
+        this._focusableElement?.focus();
+    }
+    _renderConfigPickers() {
+        if (!this._container) {
+            return;
+        }
+        const session = this._session.get();
+        const pickerClosedBySessionChange = !!this._openedPickerSessionId && this._openedPickerSessionId !== session?.sessionId;
+        const activeElement = getActiveElement();
+        const focusedProperty = this._container.contains(activeElement) ? activeElement?.closest("[data-session-config-property]")?.dataset.sessionConfigProperty : undefined;
+        const restoreFocus = focusedProperty !== undefined || this._focusableElement === activeElement || pickerClosedBySessionChange;
+        let focusToRestore;
+        this._renderDisposables.clear();
+        this._focusableElement = undefined;
+        const checkboxSlots = ( new Set([this._isolationCheckbox.value?.slot]));
+        for (const child of Array.from(this._container.children)) {
+            if (!( checkboxSlots.has(child))) {
+                child.remove();
+            }
+        }
+        if (pickerClosedBySessionChange) {
+            this._actionWidgetService.hide(true);
+            this._openedPickerSessionId = undefined;
+        }
+        this._evictDynamicValueLabelsForOtherSessions(session?.sessionId);
+        const provider = session ? this._getProvider(session.providerId) : undefined;
+        const resolvedConfig = session && provider?.getSessionConfig(session.sessionId);
+        if (!session || !provider || !resolvedConfig) {
+            this._isolationCheckbox.clear();
+            return;
+        }
+        const isNewSession = provider.getCreateSessionConfig(session.sessionId) !== undefined;
+        const isLoading = provider.isSessionConfigResolving(session.sessionId).get();
+        const properties = this._orderProperties(Object.entries(resolvedConfig.schema.properties));
+        let renderedIsolationCheckbox = false;
+        for (const [property, schema] of properties) {
+            if (this._property !== undefined && property !== this._property) {
+                continue;
+            }
+            if (!isRenderableSessionConfigProperty(property, schema, resolvedConfig.schema, isNewSession)) {
+                continue;
+            }
+            if (!this._shouldRenderProperty(property, schema, isNewSession)) {
+                continue;
+            }
+            const value = resolvedConfig.values[property] ?? schema.default;
+            const presentation = getSessionConfigPresentationKey(property, resolvedConfig.schema);
+            const isReadOnly = this._isReadOnlyChip(property, schema, isNewSession) || (this._requiresBranchCheckout(provider, session.sessionId, property) && !this._getCheckoutChangeset(session.sessionId));
+            if (presentation === SessionConfigKey.Isolation && !isNewSession && this._shouldRenderIsolationAsCheckbox(schema)) {
+                this._renderIsolationCheckbox(
+                    provider,
+                    session.sessionId,
+                    schema,
+                    value,
+                    isReadOnly,
+                    !isReadOnly && isLoading
+                );
+                this._focusableElement = this._isolationCheckbox.value?.checkbox.domNode;
+                renderedIsolationCheckbox = true;
+                continue;
+            }
+            const slot = append(this._container, $(".sessions-chat-picker-slot"));
+            slot.dataset.sessionConfigProperty = property;
+            if (presentation === SessionConfigKey.Isolation) {
+                slot.classList.add("sessions-chat-isolation-picker");
+                this._renderDisposables.add(markOnboardingTarget(slot, "sessions.newSession.isolation"));
+            }
+            const trigger = renderPickerTrigger(slot, isReadOnly, this._renderDisposables, () => {
+                void this._showPicker(provider, session.sessionId, property, schema, trigger).catch(onUnexpectedError);
+            });
+            this._focusableElement = trigger;
+            if (property === focusedProperty) {
+                focusToRestore = trigger;
+            }
+            const tooltip = presentation !== SessionConfigKey.Branch ? (schema.description ?? schema.title) : undefined;
+            if (tooltip) {
+                this._renderDisposables.add(this._hoverService.setupDelayedHover(trigger, {
+                    content: tooltip
+                }));
+            }
+            if (!isReadOnly && isLoading) {
+                slot.classList.add("resolving");
+                trigger.setAttribute("aria-disabled", "true");
+            }
+            this._renderTrigger(trigger, session.sessionId, property, schema, value, isReadOnly);
+        }
+        if (!renderedIsolationCheckbox) {
+            this._isolationCheckbox.clear();
+        }
+        this.setFocusable(this._focusable);
+        const focusTarget = focusToRestore ?? this._focusableElement;
+        if (restoreFocus && focusTarget?.isConnected) {
+            focusTarget.focus();
+        }
+    }
+    _orderProperties(properties) {
+        return orderSessionConfigProperties(properties, false);
+    }
+    _shouldRenderProperty(property, schema, isNewSession) {
+        return isNewSession || !!schema.sessionMutable;
+    }
+    _isReadOnlyChip(property, schema, isNewSession) {
+        return !!schema.readOnly;
+    }
+    async _setSessionConfigValue(provider, sessionId, property, value) {
+        const presentation = this._presentationProperty(sessionId, property);
+        const isDraftRepositoryProperty = provider.getCreateSessionConfig(sessionId) !== undefined && (presentation === SessionConfigKey.Isolation || presentation === SessionConfigKey.Branch);
+        if (!isDraftRepositoryProperty) {
+            await provider.setSessionConfigValue(sessionId, property, value);
+            return;
+        }
+        let treeish;
+        if (presentation === SessionConfigKey.Branch) {
+            if (typeof value !== "string" || value.length === 0) {
+                throw ( new Error("Branch configuration values must be non-empty strings."));
+            }
+            treeish = value;
+        }
+        const configOperation = repositoryConfigSequencer.queue(sessionId, async () => {
+            const shouldCheckout = this._requiresBranchCheckout(provider, sessionId, property);
+            if (!shouldCheckout) {
+                await provider.setSessionConfigValue(sessionId, property, value);
+                return;
+            }
+            if (!treeish) {
+                throw ( new Error("Branch checkout requires a non-empty treeish."));
+            }
+            const changeset = this._getCheckoutChangeset(sessionId);
+            if (!changeset) {
+                throw ( new Error("Branch checkout is not available for this session."));
+            }
+            const checkedOut = await this._invokeCheckoutOperation(changeset, treeish);
+            if (checkedOut) {
+                await provider.setSessionConfigValue(sessionId, property, value);
+            }
+        });
+        provider.trackSessionConfigOperation(sessionId, configOperation);
+        await configOperation;
+    }
+    async _invokeCheckoutOperation(changeset, treeish) {
+        let errorMessage;
+        try {
+            await changeset.invokeOperation(
+                AGENT_HOST_CHECKOUT_CHANGESET_OPERATION_ID,
+                undefined,
+                checkoutOperationMeta(treeish)
+            );
+            return true;
+        } catch (error) {
+            if (!(error instanceof ProtocolError) || !isCheckoutOperationDirtyWorkingTreeErrorData(error.data)) {
+                throw error;
+            }
+            errorMessage = error instanceof Error ? error.message : String(error);
+        }
+        const {
+            result
+        } = await this._dialogService.prompt({
+            type: "warning",
+            message: ( localize(
+                4876,
+                "Your local changes would be overwritten when checking out '{0}'.",
+                treeish
+            )),
+            detail: ( new MarkdownString(errorMessage)),
+            buttons: [{
+                label: ( localize(4877, "Stash & Checkout")),
+                run: () => CheckoutOperationPreAction.Stash
+            }, {
+                label: ( localize(4878, "Commit & Checkout")),
+                run: () => CheckoutOperationPreAction.Commit
+            }],
+            cancelButton: true
+        });
+        if (!result) {
+            return false;
+        }
+        await changeset.invokeOperation(
+            AGENT_HOST_CHECKOUT_CHANGESET_OPERATION_ID,
+            undefined,
+            checkoutOperationMeta(treeish, result)
+        );
+        return true;
+    }
+    _requiresBranchCheckout(provider, sessionId, property) {
+        const config = provider.getSessionConfig(sessionId);
+        const workspace = config && getSessionWorkspaceProperties(config.schema);
+        return property === workspace?.baseBranch?.key && workspace.isolationKey === SessionConfigKey.Isolation && provider.getCreateSessionConfig(sessionId) !== undefined && provider.getSessionConfig(sessionId)?.values[SessionConfigKey.Isolation] === "folder";
+    }
+    _getCheckoutChangeset(sessionId) {
+        const session = this._session.get();
+        if (session?.sessionId !== sessionId) {
+            return undefined;
+        }
+        return session.activeChat.get().changesets.get()?.find(
+            changeset => changeset.id === UNCOMMITTED_CHANGES_CHANGESET_ID && ( changeset.operations.get().some(operation => operation.id === AGENT_HOST_CHECKOUT_CHANGESET_OPERATION_ID))
+        );
+    }
+    _renderTrigger(trigger, sessionId, property, schema, value, isReadOnly) {
+        clearNode(trigger);
+        const presentation = this._presentationProperty(sessionId, property);
+        const icon = getConfigIcon(presentation, value === "workspace" ? "folder" : value);
+        const iconElement = icon ? append(trigger, renderIcon(icon)) : undefined;
+        const labelSpan = append(trigger, $("span.sessions-chat-dropdown-label"));
+        const label = this._getLabel(sessionId, property, schema, value);
+        labelSpan.textContent = label;
+        trigger.setAttribute("aria-label", triggerAriaLabel(schema.title, label, isReadOnly, false));
+        if (presentation === SessionConfigKey.Branch && icon && iconElement) {
+            this._trackBranchRepositoryState(trigger, iconElement, icon, schema, label, value, isReadOnly);
+        } else if (property === SessionConfigKey.AutoApprove) {
+            trigger.classList.toggle("warning", value === "autopilot" || value === "assisted");
+            trigger.classList.toggle("info", value === "autoApprove");
+        }
+    }
+    _trackBranchRepositoryState(trigger, iconElement, icon, schema, label, value, isReadOnly) {
+        let appliedHoverContent;
+        const hover = this._renderDisposables.add(( new MutableDisposable()));
+        this._renderDisposables.add(autorun(reader => {
+            const session = this._session.read(reader);
+            const repository = session?.workspace.read(reader)?.folders[0]?.gitRepository;
+            const uncommittedChanges = typeof value === "string" ? getBranchUncommittedChanges(value, repository?.branchName, repository?.uncommittedChanges) : undefined;
+            const hasUncommittedChanges = uncommittedChanges !== undefined;
+            iconElement.className = "";
+            iconElement.classList.add(
+                ...ThemeIcon.asClassNameArray(hasUncommittedChanges ? Codicon.gitBranchChanges : icon)
+            );
+            trigger.setAttribute(
+                "aria-label",
+                triggerAriaLabel(schema.title, label, isReadOnly, hasUncommittedChanges)
+            );
+            const branchName = schema.description ?? schema.title;
+            const content = !hasUncommittedChanges ? branchName : uncommittedChanges === 1 ? ( localize(4879, "{0}, {1} uncommitted file", branchName, uncommittedChanges)) : ( localize(4880, "{0}, {1} uncommitted files", branchName, uncommittedChanges));
+            if (appliedHoverContent !== content) {
+                appliedHoverContent = content;
+                hover.clear();
+                hover.value = content ? this._hoverService.setupDelayedHover(trigger, {
+                    content
+                }) : undefined;
+            }
+        }));
+    }
+    _shouldRenderIsolationAsCheckbox(schema) {
+        return !isPhoneLayout(this._layoutService) && Array.isArray(schema.enum) && schema.enum.includes("worktree") && (schema.enum.includes("folder") || schema.enum.includes("workspace"));
+    }
+    _renderIsolationCheckbox(provider, sessionId, schema, value, isReadOnly, isLoading) {
+        const label = NEW_WORKTREE_LABEL;
+        const worktreeIndex = schema.enum?.indexOf("worktree") ?? -1;
+        const checked = value === "worktree";
+        const combinationDisabled = !this._isDevContainerWorktreeEnabled() && provider.isDevContainerEnabled?.(sessionId) === true && !checked;
+        const tooltip = combinationDisabled ? ( localize(4881, "New Worktree cannot be combined with Dev Container execution.")) : (worktreeIndex >= 0 ? schema.enumDescriptions?.[worktreeIndex] : undefined) ?? schema.description ?? schema.title;
+        let control = this._isolationCheckbox.value;
+        if (!control || control.sessionId !== sessionId) {
+            control = ( new ConfigCheckboxControl(
+                sessionId,
+                label,
+                "sessions-chat-isolation-checkbox",
+                this._hoverService,
+                checked => this._applyIsolationValue(sessionId, checked),
+                "sessions.newSession.isolation"
+            ));
+            this._isolationCheckbox.value = control;
+            this._container?.prepend(control.slot);
+        }
+        control.update(checked, isReadOnly || combinationDisabled, isLoading, tooltip);
+    }
+    _isDevContainerWorktreeEnabled() {
+        const workspace = this._session.get()?.workspace.get()?.uri;
+        return !(workspace && findDevContainerSample(workspace)) && this._configurationService.getValue(DevContainerWorktreeEnabledSettingId) === true;
+    }
+    _applyIsolationValue(sessionId, checked) {
+        const session = this._session.get();
+        if (!session || session.sessionId !== sessionId) {
+            return;
+        }
+        const provider = this._getProvider(session.providerId);
+        const resolvedConfig = provider?.getSessionConfig(sessionId);
+        const isolationProperty = resolvedConfig && getSessionWorkspaceProperties(resolvedConfig.schema).isolation;
+        if (!provider || !resolvedConfig || !isolationProperty) {
+            return;
+        }
+        const {
+            key: property,
+            schema
+        } = isolationProperty;
+        const before = resolvedConfig.values[property] ?? schema.default;
+        const nextValue = writeSessionIsolation(isolationProperty, checked ? "worktree" : "folder");
+        if (nextValue === undefined || !isSessionConfigWritable(schema, provider.getCreateSessionConfig(sessionId) !== undefined)) {
+            return;
+        }
+        reportNewChatPickerClosed(this._telemetryService, {
+            id: "NewChatAgentHostSessionConfigPicker",
+            name: `NewChatAgentHostSessionConfigPicker.${property}`,
+            optionIdBefore: typeof before === "string" ? before : undefined,
+            optionIdAfter: nextValue,
+            optionLabelBefore: typeof before === "string" ? this._getLabel(sessionId, property, schema, before) : undefined,
+            optionLabelAfter: this._getLabel(sessionId, property, schema, nextValue),
+            isPII: false
+        });
+        this._setSessionConfigValue(provider, sessionId, property, nextValue).catch(onUnexpectedError);
+    }
+    async _showPicker(provider, sessionId, property, schema, trigger) {
+        if (!isSessionConfigWritable(schema, provider.getCreateSessionConfig(sessionId) !== undefined) || this._actionWidgetService.isVisible || !this._isCurrentSession(provider, sessionId)) {
+            return;
+        }
+        if (provider.isSessionConfigResolving(sessionId).get()) {
+            return;
+        }
+        const presentation = this._presentationProperty(sessionId, property);
+        if (presentation === "newBranch" && !schema.enum && !schema.enumDynamic) {
+            const value = await this._quickInputService.input({
+                title: schema.title,
+                prompt: schema.description,
+                value: String(
+                    provider.getSessionConfig(sessionId)?.values[property] ?? schema.default ?? ""
+                )
+            });
+            if (value !== undefined && this._isCurrentSession(provider, sessionId)) {
+                await this._setSessionConfigValue(provider, sessionId, property, value);
+            }
+            return;
+        }
+        const branchCompletions = presentation === SessionConfigKey.Branch && schema.enumDynamic ? await provider.getSessionConfigCompletions(sessionId, property) : undefined;
+        const rawItems = await this._getItems(provider, sessionId, property, schema, undefined, branchCompletions);
+        if (!this._isCurrentSession(provider, sessionId)) {
+            return;
+        }
+        const {
+            items,
+            policyRestricted
+        } = applyAutoApproveFiltering(rawItems, property, this._configurationService);
+        const isAutoApproveProperty = property === SessionConfigKey.AutoApprove;
+        const config = provider.getSessionConfig(sessionId);
+        const currentValue = config?.values[property] ?? schema.default;
+        const currentItem = items.find(i => isSelectedValue(currentValue, i.value));
+        const isBranchPicker = presentation === SessionConfigKey.Branch;
+        const isolationKey = config && getSessionWorkspaceProperties(config.schema).isolation?.key;
+        const repositoryConfigContainer = isBranchPicker ? trigger.closest(".new-chat-repo-config-container") : undefined;
+        const repositoryState = isBranchPicker ? this._getRepositoryBranchState(sessionId) : undefined;
+        const onShowChanges = isBranchPicker ? () => this._showChanges() : undefined;
+        const actionItems = toActionItems(presentation, items, currentValue, policyRestricted, {
+            ...repositoryState,
+            isWorktree: isolationKey !== undefined && config?.values[isolationKey] === "worktree",
+            onShowChanges
+        });
+        if (actionItems.length === 0) {
+            return;
+        }
+        const filterItems = async query => {
+            if (!this._isCurrentSession(provider, sessionId)) {
+                return [];
+            }
+            const filteredRawItems = await this._getItems(provider, sessionId, property, schema, query, branchCompletions);
+            if (!this._isCurrentSession(provider, sessionId)) {
+                return [];
+            }
+            const {
+                items: filteredItems,
+                policyRestricted: filteredPolicyRestricted
+            } = applyAutoApproveFiltering(filteredRawItems, property, this._configurationService);
+            const filteredRepositoryState = this._getRepositoryBranchState(sessionId);
+            const filteredConfig = provider.getSessionConfig(sessionId);
+            return toActionItems(
+                presentation,
+                filteredItems,
+                filteredConfig?.values[property] ?? schema.default,
+                filteredPolicyRestricted,
+                {
+                    ...filteredRepositoryState,
+                    isWorktree: isolationKey !== undefined && filteredConfig?.values[isolationKey] === "worktree",
+                    query,
+                    onShowChanges
+                }
+            );
+        };
+        const delegate = {
+            onSelect: async item => {
+                this._actionWidgetService.hide();
+                if (item.disabled || !this._isCurrentSession(provider, sessionId) || provider.isSessionConfigResolving(sessionId).get()) {
+                    return;
+                }
+                if (presentation === SessionConfigKey.Isolation && item.value === "worktree" && !this._isDevContainerWorktreeEnabled() && provider.isDevContainerEnabled?.(sessionId)) {
+                    return;
+                }
+                reportNewChatPickerClosed(this._telemetryService, {
+                    id: "NewChatAgentHostSessionConfigPicker",
+                    name: `NewChatAgentHostSessionConfigPicker.${property}`,
+                    optionIdBefore: typeof currentValue === "string" ? currentValue : undefined,
+                    optionIdAfter: item.value,
+                    optionLabelBefore: currentItem?.label,
+                    optionLabelAfter: item.label,
+                    isPII: !!schema.enumDynamic
+                });
+                if (isAutoApproveProperty && item.value !== "default") {
+                    const confirmed = await confirmAutoApproveLevel(item.value, item.label, this._dialogService, this._storageService);
+                    if (!confirmed) {
+                        return;
+                    }
+                }
+                const nextValue = schema.type === "boolean" ? item.value === "true" : item.value;
+                this._setSessionConfigValue(provider, sessionId, property, nextValue).catch(error => {
+                    if (!isCancellationError(error)) {
+                        this._notificationService.error(error);
+                    }
+                });
+            },
+            onFilter: schema.enumDynamic ? query => branchCompletions !== undefined ? filterItems(query) : this._filterDelayer.trigger(() => filterItems(query)) : undefined,
+            onHide: () => {
+                this._openedPickerSessionId = undefined;
+                trigger.setAttribute("aria-expanded", "false");
+                repositoryConfigContainer?.removeAttribute(PICKER_OPEN_ATTRIBUTE);
+                if (this._isCurrentSession(provider, sessionId)) {
+                    trigger.focus();
+                }
+            }
+        };
+        this._openedPickerSessionId = sessionId;
+        trigger.setAttribute("aria-expanded", "true");
+        repositoryConfigContainer?.setAttribute(PICKER_OPEN_ATTRIBUTE, "true");
+        const showFilter = (branchCompletions ?? items).length > 10;
+        this._actionWidgetService.show(
+            `agentHostSessionConfig.${property}`,
+            false,
+            actionItems,
+            delegate,
+            trigger,
+            undefined,
+            [],
+            {
+                getAriaLabel: item => {
+                    const label = item.badge ? ( localize(4882, "{0}, {1}", item.label ?? "", item.badge)) : item.label ?? "";
+                    const groupLabel = item.group?.title ? ( localize(4883, "{0}, {1}", label, item.group.title)) : label;
+                    return item.ariaDescription ? ( localize(4884, "{0}, {1}", groupLabel, item.ariaDescription)) : groupLabel;
+                },
+                getWidgetAriaLabel: () => ( localize(4885, "{0} Picker", schema.title))
+            },
+            {
+                ...(showFilter ? {
+                    showFilter: true,
+                    filterPlaceholder: ( localize(4886, "Filter options..."))
+                } : {}),
+                minWidth: 255,
+                anchorPosition: AnchorPosition.BELOW,
+                maxVisibleItems: isBranchPicker ? BRANCH_PICKER_MAX_VISIBLE_ITEMS : undefined
+            }
+        );
+        if (isBranchPicker && typeof currentValue === "string" && ( actionItems.some(item => item.item?.value === currentValue))) {
+            this._actionWidgetService.focusItemById(currentValue);
+        }
+    }
+    _isCurrentSession(provider, sessionId) {
+        const session = this._session.get();
+        return !!session && session.sessionId === sessionId && this._getProvider(session.providerId) === provider;
+    }
+    async _showChanges() {
+        this._actionWidgetService.hide();
+        const session = this._session.get();
+        if (this._layoutService.agentWorkbenchLayout === AgentWorkbenchLayout.Desktop && session) {
+            if ((this._getRepositoryBranchState(session.sessionId).uncommittedChanges ?? 0) > 0) {
+                this._layoutService.revealEditorPartExplicitly();
+            }
+            const suppression = this._layoutService.suppressEditorPartAutoVisibility();
+            try {
+                await this._sessionChangesService.openChangesEditor(session.resource);
+            } finally {
+                suppression.dispose();
+            }
+        }
+        await this._viewsService.openView(CHANGES_VIEW_ID, true);
+    }
+    _getRepositoryBranchState(sessionId) {
+        const session = this._session.get();
+        const repository = session?.sessionId === sessionId ? session.workspace.get()?.folders[0]?.gitRepository : undefined;
+        return {
+            branchName: repository?.branchName,
+            upstreamBranchName: repository?.upstreamBranchName,
+            defaultBranchName: repository?.defaultBranchName,
+            defaultRemoteBranchName: repository?.defaultRemoteBranchName,
+            uncommittedChanges: repository?.uncommittedChanges
+        };
+    }
+    async _getItems(
+        provider,
+        sessionId,
+        property,
+        schema,
+        query,
+        branchCompletions,
+        branchResultLimit
+    ) {
+        if (this._isNewSessionIsolationPicker(sessionId, property, schema)) {
+            const worktreeDisabled = !this._isDevContainerWorktreeEnabled() && provider.isDevContainerEnabled?.(sessionId) === true;
+            return [schema.enum?.includes("workspace") ? "workspace" : "folder", "worktree"].filter(value => schema.enum?.includes(value)).map(value => ({
+                value,
+                label: this._getLabel(sessionId, property, schema, value),
+                description: value === "worktree" ? worktreeDisabled ? ( localize(4881, "New Worktree cannot be combined with Dev Container execution.")) : ( localize(4887, "Creates a separate copy for this session")) : ( localize(4888, "Works in the repository already on your machine")),
+                disabled: value === "worktree" && worktreeDisabled
+            }));
+        }
+        if (schema.type === "boolean") {
+            return [{
+                value: "true",
+                label: ( localize(4889, "On"))
+            }, {
+                value: "false",
+                label: ( localize(4890, "Off"))
+            }];
+        }
+        const isBaseBranch = this._presentationProperty(sessionId, property) === SessionConfigKey.Branch;
+        const dynamicItems = schema.enumDynamic ? branchCompletions ?? (await provider.getSessionConfigCompletions(sessionId, property, isBaseBranch ? undefined : query || undefined)) : undefined;
+        if (dynamicItems) {
+            const items = (isBaseBranch ? filterBranchPickerItems(dynamicItems, query, branchResultLimit) : dynamicItems).map(item => this._fromCompletionItem(item));
+            this._cacheDynamicValueLabels(sessionId, property, items);
+            return items;
+        }
+        return (schema.enum ?? []).map((value, index) => ({
+            value: String(value),
+            label: schema.enumLabels?.[index] ?? String(value),
+            description: schema.enumDescriptions?.[index]
+        }));
+    }
+    _fromCompletionItem(item) {
+        return {
+            value: item.value,
+            label: item.label,
+            description: item.description
+        };
+    }
+    _dynamicValueLabelsKey(sessionId, property) {
+        return `${sessionId}\0${property}`;
+    }
+    _cacheDynamicValueLabels(sessionId, property, items) {
+        const key = this._dynamicValueLabelsKey(sessionId, property);
+        let labels = this._dynamicValueLabels.get(key);
+        if (!labels) {
+            labels = ( new Map());
+            this._dynamicValueLabels.set(key, labels);
+        }
+        for (const item of items) {
+            labels.set(item.value, item.label);
+        }
+    }
+    _evictDynamicValueLabelsForOtherSessions(sessionId) {
+        if (!sessionId) {
+            return;
+        }
+        const prefix = `${sessionId}\0`;
+        for (const key of ( this._dynamicValueLabels.keys())) {
+            if (!key.startsWith(prefix)) {
+                this._dynamicValueLabels.delete(key);
+            }
+        }
+    }
+    _getLabel(sessionId, property, schema, value) {
+        if (this._isNewSessionIsolationPicker(sessionId, property, schema)) {
+            return value === "worktree" ? NEW_WORKTREE_LABEL : value === "folder" || value === "workspace" ? ( localize(4891, "Branch")) : schema.title;
+        }
+        if (schema.type === "boolean") {
+            return value === true ? ( localize(4892, "On")) : ( localize(4893, "Off"));
+        }
+        if (typeof value === "string") {
+            if (schema.enumDynamic) {
+                const key = this._dynamicValueLabelsKey(sessionId, property);
+                const dynamicLabel = this._dynamicValueLabels.get(key)?.get(value);
+                if (dynamicLabel) {
+                    return dynamicLabel;
+                }
+            }
+            const index = schema.enum?.indexOf(value) ?? -1;
+            return index >= 0 ? schema.enumLabels?.[index] ?? value : value;
+        }
+        return schema.title;
+    }
+    _isNewSessionIsolationPicker(sessionId, property, schema) {
+        const session = this._session.get();
+        return this._presentationProperty(sessionId, property) === SessionConfigKey.Isolation && this._shouldRenderIsolationAsCheckbox(schema) && schema.enum?.length === 2 && !schema.enumDynamic && session?.sessionId === sessionId && this._getProvider(session.providerId)?.getCreateSessionConfig(sessionId) !== undefined;
+    }
+    _getProvider(providerId) {
+        const provider = this._sessionsProvidersService.getProvider(providerId);
+        return provider && isAgentHostProvider(provider) ? provider : undefined;
+    }
+    _presentationProperty(sessionId, property) {
+        const session = this._session.get();
+        const config = session?.sessionId === sessionId ? this._getProvider(session.providerId)?.getSessionConfig(sessionId) : undefined;
+        return config ? getSessionConfigPresentationKey(property, config.schema) : property;
+    }
+};
+AgentHostSessionConfigPicker = ( __decorate([( __param(2, IActionWidgetService)), ( __param(3, IConfigurationService)), ( __param(4, IContextKeyService)), ( __param(5, IDialogService)), ( __param(6, IHoverService)), ( __param(7, ISessionsProvidersService)), ( __param(8, ITelemetryService)), ( __param(9, IAgentWorkbenchLayoutService)), ( __param(10, IStorageService)), ( __param(11, ISessionChangesService)), ( __param(12, IViewsService)), ( __param(13, INotificationService)), ( __param(14, IQuickInputService))], AgentHostSessionConfigPicker));
+class MobileAgentHostSessionConfigPicker extends AgentHostSessionConfigPicker {
+    _orderProperties(properties) {
+        return orderSessionConfigProperties(properties, isPhoneLayout(this._layoutService));
+    }
+    _shouldRenderProperty(property, schema, isNewSession) {
+        const session = this._session.get();
+        const presentation = session ? this._presentationProperty(session.sessionId, property) : property;
+        const isUnifiedRepoProperty = presentation === SessionConfigKey.Isolation || presentation === SessionConfigKey.Branch;
+        return isUnifiedRepoProperty || super._shouldRenderProperty(property, schema, isNewSession);
+    }
+    _isReadOnlyChip(property, schema, isNewSession) {
+        return super._isReadOnlyChip(property, schema, isNewSession) || (!isNewSession && !schema.sessionMutable);
+    }
+    async _showPicker(provider, sessionId, property, schema, trigger) {
+        if (!isPhoneLayout(this._layoutService)) {
+            return super._showPicker(provider, sessionId, property, schema, trigger);
+        }
+        if (provider.isSessionConfigResolving(sessionId).get()) {
+            return;
+        }
+        const presentation = this._presentationProperty(sessionId, property);
+        if (presentation === SessionConfigKey.Isolation || presentation === SessionConfigKey.Branch) {
+            await this._showUnifiedRepoSheet(provider, sessionId, trigger);
+            return;
+        }
+        return super._showPicker(provider, sessionId, property, schema, trigger);
+    }
+    async _showUnifiedRepoSheet(provider, sessionId, trigger) {
+        if (!this._isCurrentSession(provider, sessionId)) {
+            return;
+        }
+        const config = provider.getSessionConfig(sessionId);
+        if (!config) {
+            return;
+        }
+        const workspace = getSessionWorkspaceProperties(config.schema);
+        const isolationProperty = workspace.isolationKey;
+        const branchProperty = workspace.baseBranchKey;
+        const isolationSchema = workspace.isolation?.schema;
+        const branchSchema = workspace.baseBranch?.schema;
+        const isNewSession = provider.getCreateSessionConfig(sessionId) !== undefined;
+        const canSelectIsolation = isSessionConfigWritable(isolationSchema, isNewSession);
+        const canSelectBranch = isSessionConfigWritable(branchSchema, isNewSession) && (!this._requiresBranchCheckout(provider, sessionId, branchProperty) || !!this._getCheckoutChangeset(sessionId));
+        const branchCompletions = branchSchema?.enumDynamic && canSelectBranch ? await provider.getSessionConfigCompletions(sessionId, branchProperty) : undefined;
+        const [isolationItems, branchItems] = await Promise.all([
+            isolationSchema && canSelectIsolation ? this._getItems(provider, sessionId, isolationProperty, isolationSchema) : Promise.resolve([]),
+            branchSchema && canSelectBranch ? this._getItems(
+                provider,
+                sessionId,
+                branchProperty,
+                branchSchema,
+                undefined,
+                branchCompletions,
+                MOBILE_BRANCH_PICKER_RESULT_LIMIT
+            ) : Promise.resolve([])
+        ]);
+        if (!this._isCurrentSession(provider, sessionId)) {
+            return;
+        }
+        const isolationValue = config.values[isolationProperty] ?? isolationSchema?.default;
+        const branchValue = config.values[branchProperty] ?? branchSchema?.default;
+        const repositoryState = this._getRepositoryBranchState(sessionId);
+        const sheetItems = [];
+        const idToConfig = ( new Map());
+        const registerId = (property, item, isPII) => {
+            const id = `${property}\0${item.value}`;
+            if (!( idToConfig.has(id))) {
+                idToConfig.set(id, {
+                    property,
+                    ...item,
+                    isPII
+                });
+            }
+            return id;
+        };
+        isolationItems.forEach((item, index) => {
+            sheetItems.push({
+                id: registerId(isolationProperty, item, !!isolationSchema?.enumDynamic),
+                label: item.label,
+                description: item.description,
+                icon: getConfigIcon(
+                    SessionConfigKey.Isolation,
+                    item.value === "workspace" ? "folder" : item.value
+                ),
+                checked: item.value === isolationValue,
+                sectionTitle: index === 0 ? (isolationSchema?.title ?? ( localize(4894, "Isolation"))) : undefined
+            });
+        });
+        const branchSectionTitle = branchSchema?.title ?? ( localize(4895, "Base Branch"));
+        if (!branchSchema?.enumDynamic) {
+            branchItems.forEach((item, index) => {
+                const uncommittedChanges = getBranchUncommittedChanges(item.value, repositoryState.branchName, repositoryState.uncommittedChanges);
+                sheetItems.push({
+                    id: registerId(branchProperty, item, !!branchSchema?.enumDynamic),
+                    label: item.label,
+                    description: uncommittedChanges !== undefined ? formatUncommittedChanges(uncommittedChanges) : item.description,
+                    icon: getConfigIcon(SessionConfigKey.Branch, item.value, uncommittedChanges !== undefined),
+                    checked: item.value === branchValue,
+                    sectionTitle: index === 0 ? branchSectionTitle : undefined
+                });
+            });
+        }
+        if (sheetItems.length === 0 && !branchSchema?.enumDynamic) {
+            return;
+        }
+        let search;
+        if (branchSchema?.enumDynamic && canSelectBranch) {
+            search = {
+                placeholder: ( localize(4896, "Search branches")),
+                ariaLabel: ( localize(4897, "Search base branches")),
+                resultsSectionTitle: branchSectionTitle,
+                emptyMessage: ( localize(4898, "No matching branches.")),
+                loadItems: async (query, token) => {
+                    const items = query ? await this._getItems(
+                        provider,
+                        sessionId,
+                        branchProperty,
+                        branchSchema,
+                        query,
+                        branchCompletions,
+                        MOBILE_BRANCH_PICKER_RESULT_LIMIT
+                    ) : branchItems;
+                    if (token.isCancellationRequested || !this._isCurrentSession(provider, sessionId)) {
+                        return [];
+                    }
+                    return items.map(item => {
+                        const uncommittedChanges = getBranchUncommittedChanges(item.value, repositoryState.branchName, repositoryState.uncommittedChanges);
+                        return {
+                            id: registerId(branchProperty, item, !!branchSchema.enumDynamic),
+                            label: item.label,
+                            description: uncommittedChanges !== undefined ? formatUncommittedChanges(uncommittedChanges) : item.description,
+                            icon: getConfigIcon(SessionConfigKey.Branch, item.value, uncommittedChanges !== undefined),
+                            checked: item.value === branchValue
+                        };
+                    });
+                }
+            };
+        }
+        trigger.setAttribute("aria-expanded", "true");
+        await showMobilePickerSheet(this._layoutService.mainContainer, ( localize(4899, "Worktree")), sheetItems, {
+            search,
+            stayOpenOnSelect: true,
+            onDidSelect: id => {
+                if (!this._isCurrentSession(provider, sessionId)) {
+                    return MOBILE_PICKER_SHEET_CONFIRM;
+                }
+                const selection = idToConfig.get(id);
+                if (selection) {
+                    const beforeValue = provider.getSessionConfig(sessionId)?.values[selection.property];
+                    reportNewChatPickerClosed(this._telemetryService, {
+                        id: "NewChatAgentHostSessionConfigPicker",
+                        name: `NewChatAgentHostSessionConfigPicker.${selection.property}`,
+                        optionIdBefore: typeof beforeValue === "string" ? beforeValue : undefined,
+                        optionIdAfter: selection.value,
+                        optionLabelBefore: undefined,
+                        optionLabelAfter: selection.label,
+                        isPII: selection.isPII
+                    });
+                    this._setSessionConfigValue(provider, sessionId, selection.property, selection.value).catch(onUnexpectedError);
+                    if (selection.property === isolationProperty) {
+                        return MOBILE_PICKER_SHEET_CONFIRM;
+                    }
+                }
+                return undefined;
+            }
+        });
+        trigger.setAttribute("aria-expanded", "false");
+        trigger.focus();
+    }
+}
+class PickerActionViewItem extends BaseActionViewItem {
+    constructor(_picker, disposable, _manageFocusableElement = false) {
+        super(undefined, {
+            id: "",
+            label: "",
+            enabled: true,
+            class: undefined,
+            tooltip: "",
+            run: () => {}
+        });
+        this._picker = _picker;
+        this._manageFocusableElement = _manageFocusableElement;
+        this._compact = false;
+        if (disposable) {
+            this._register(disposable);
+        }
+    }
+    render(container) {
+        this.element = container;
+        this._focusableElement = this._picker.render(container) ?? undefined;
+        container.classList.toggle("compact-picker", this._compact);
+    }
+    focus() {
+        if (this._manageFocusableElement) {
+            if (this._picker.setFocusable) {
+                this._picker.setFocusable(true);
+            } else if (this._focusableElement) {
+                this._focusableElement.tabIndex = 0;
+            }
+            if (this._picker.focus) {
+                this._picker.focus();
+            } else {
+                this._focusableElement?.focus();
+            }
+            return;
+        }
+        if (this._picker.focus) {
+            this._picker.focus();
+        } else if (this._focusableElement) {
+            this._focusableElement.focus();
+        } else if (this.element) {
+            this._focusFirstTabStop(this.element);
+        } else {
+            super.focus();
+        }
+    }
+    isFocused() {
+        return this.element ? isAncestorOfActiveElement(this.element) : super.isFocused();
+    }
+    blur() {
+        if (this._manageFocusableElement) {
+            if (this._picker.setFocusable) {
+                this._picker.setFocusable(false);
+            } else if (this._focusableElement) {
+                this._focusableElement.tabIndex = -1;
+            }
+            const activeElement = getActiveElement();
+            if (this.element && isHTMLElement(activeElement) && isAncestor(activeElement, this.element)) {
+                activeElement.blur();
+            }
+            return;
+        }
+        const activeElement = getActiveElement();
+        if (this.element && isHTMLElement(activeElement) && isAncestor(activeElement, this.element)) {
+            activeElement.blur();
+        } else {
+            super.blur();
+        }
+    }
+    setFocusable(focusable) {
+        if (this.element) {
+            this.element.tabIndex = -1;
+            if (this._manageFocusableElement) {
+                if (this._picker.setFocusable) {
+                    this._picker.setFocusable(focusable);
+                } else if (this._focusableElement) {
+                    this._focusableElement.tabIndex = focusable ? 0 : -1;
+                }
+            }
+        }
+    }
+    _focusFirstTabStop(container) {
+        for (const child of container.children) {
+            if (!isHTMLElement(child)) {
+                continue;
+            }
+            if (child.tabIndex >= 0) {
+                child.focus();
+                if (isActiveElement(child)) {
+                    return true;
+                }
+            }
+            if (this._focusFirstTabStop(child)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    isCompact() {
+        return this._compact;
+    }
+    setCompact(compact) {
+        this._compact = compact;
+        this.element?.classList.toggle("compact-picker", compact);
+    }
+    show(anchor) {
+        const target = anchor ?? this.element;
+        if (target) {
+            this._picker.showPicker?.(target);
+        }
+    }
+    dispose() {
+        this._picker.dispose();
+        super.dispose();
+    }
+}
+let AgentHostSessionConfigPickerContribution = class AgentHostSessionConfigPickerContribution extends Disposable {
+    static {
+        this.ID = "sessions.contrib.agentHostSessionConfigPicker";
+    }
+    constructor(
+        actionViewItemService,
+        _layoutService,
+        _contextKeyService,
+        _sessionsProvidersService,
+        _sessionsService,
+        _configurationService
+    ) {
+        super();
+        this._layoutService = _layoutService;
+        this._contextKeyService = _contextKeyService;
+        this._sessionsProvidersService = _sessionsProvidersService;
+        this._sessionsService = _sessionsService;
+        this._configurationService = _configurationService;
+        this._repositoryMenuItems = this._register(( new DisposableStore()));
+        this._repositoryPropertyRegistrations = this._register(( new DisposableMap()));
+        this._providerListeners = this._register(( new DisposableMap()));
+        this._register(autorun(reader => {
+            this._sessionsService.visibleSessions.read(reader);
+            this._refreshRepositoryMenuItems(actionViewItemService);
+        }));
+        this._watchProviders(this._sessionsProvidersService.getProviders(), actionViewItemService);
+        this._register(this._sessionsProvidersService.onDidChangeProviders(e => {
+            for (const provider of e.removed) {
+                this._providerListeners.deleteAndDispose(provider.id);
+            }
+            this._watchProviders(e.added, actionViewItemService);
+            this._refreshRepositoryMenuItems(actionViewItemService);
+        }));
+        this._register(this._contextKeyService.onDidChangeContext(e => {
+            if (e.affectsSome(( new Set([IsPhoneLayoutContext.key])))) {
+                this._refreshRepositoryMenuItems(actionViewItemService);
+            }
+        }));
+        this._register(this._configurationService.onDidChangeConfiguration(e => {
+            if (e.affectsConfiguration(EXPERIMENTAL_NEW_SESSION_COMPOSER_LAYOUT_SETTING) || e.affectsConfiguration(UNIFIED_WORKSPACE_PICKER_SETTING)) {
+                this._refreshRepositoryMenuItems(actionViewItemService);
+            }
+        }));
+        this._register(actionViewItemService.register(
+            Menus.NewSessionControl,
+            NEW_SESSION_MODE_PICKER_ID,
+            (_action, _options, scopedInstantiationService) => {
+                const {
+                    session
+                } = scopedInstantiationService.invokeFunction(accessor => accessor.get(ISessionContext));
+                return ( new PickerActionViewItem(scopedInstantiationService.createInstance(
+                    isPhoneLayout(this._layoutService) ? MobileAgentHostModePicker : AgentHostModePicker,
+                    session
+                )));
+            }
+        ));
+        const registerRunningSessionPicker = (actionId, factory) => {
+            this._register(actionViewItemService.register(MenuId.ChatInput, actionId, factory));
+            this._register(
+                actionViewItemService.register(MenuId.ChatInputSecondary, actionId, factory)
+            );
+        };
+        registerRunningSessionPicker(
+            RUNNING_SESSION_MODE_PICKER_ID,
+            (_action, _options, scopedInstantiationService) => {
+                const {
+                    session
+                } = scopedInstantiationService.invokeFunction(accessor => accessor.get(ISessionContext));
+                return ( new PickerActionViewItem(scopedInstantiationService.createInstance(
+                    isPhoneLayout(this._layoutService) ? MobileAgentHostModePicker : AgentHostModePicker,
+                    session
+                )));
+            }
+        );
+        this._register(actionViewItemService.register(
+            Menus.NewSessionControl,
+            NEW_SESSION_APPROVE_PICKER_ID,
+            (_action, _options, scopedInstantiationService) => this._createNewSessionPermissionPicker(scopedInstantiationService)
+        ));
+        this._register(actionViewItemService.register(
+            Menus.NewSessionControl,
+            NEW_SESSION_PERMISSION_MODE_PICKER_ID,
+            (_action, _options, scopedInstantiationService) => {
+                const {
+                    session
+                } = scopedInstantiationService.invokeFunction(accessor => accessor.get(ISessionContext));
+                return ( new PickerActionViewItem(
+                    scopedInstantiationService.createInstance(AgentHostClaudePermissionModePicker, session)
+                ));
+            }
+        ));
+        this._register(actionViewItemService.register(
+            Menus.NewSessionControl,
+            NEW_SESSION_CODEX_APPROVALS_PICKER_ID,
+            (_action, _options, scopedInstantiationService) => {
+                const {
+                    session
+                } = scopedInstantiationService.invokeFunction(accessor => accessor.get(ISessionContext));
+                return ( new PickerActionViewItem(
+                    scopedInstantiationService.createInstance(AgentHostCodexApprovalsPicker, session)
+                ));
+            }
+        ));
+        registerRunningSessionPicker(
+            RUNNING_SESSION_CONFIG_PICKER_ID,
+            this._createRunningSessionPermissionPickerFactory()
+        );
+        registerRunningSessionPicker(
+            RUNNING_SESSION_PERMISSION_MODE_PICKER_ID,
+            (_action, _options, scopedInstantiationService) => {
+                const {
+                    session
+                } = scopedInstantiationService.invokeFunction(accessor => accessor.get(ISessionContext));
+                return ( new PickerActionViewItem(
+                    scopedInstantiationService.createInstance(AgentHostClaudePermissionModePicker, session)
+                ));
+            }
+        );
+        registerRunningSessionPicker(
+            RUNNING_SESSION_CODEX_APPROVALS_PICKER_ID,
+            (_action, _options, scopedInstantiationService) => {
+                const {
+                    session
+                } = scopedInstantiationService.invokeFunction(accessor => accessor.get(ISessionContext));
+                return ( new PickerActionViewItem(
+                    scopedInstantiationService.createInstance(AgentHostCodexApprovalsPicker, session)
+                ));
+            }
+        );
+    }
+    _watchProviders(providers, actionViewItemService) {
+        for (const provider of providers) {
+            if (!isAgentHostProvider(provider) || ( this._providerListeners.has(provider.id))) {
+                continue;
+            }
+            this._providerListeners.set(
+                provider.id,
+                provider.onDidChangeSessionConfig(() => this._refreshRepositoryMenuItems(actionViewItemService))
+            );
+        }
+    }
+    _refreshRepositoryMenuItems(actionViewItemService) {
+        this._repositoryMenuItems.clear();
+        for (const session of this._sessionsService.visibleSessions.get()) {
+            if (!session) {
+                continue;
+            }
+            const provider = this._sessionsProvidersService.getProvider(session.providerId);
+            if (!provider || !isAgentHostProvider(provider)) {
+                continue;
+            }
+            const config = provider.getSessionConfig(session.sessionId);
+            if (!config) {
+                continue;
+            }
+            const isNewSession = provider.getCreateSessionConfig(session.sessionId) !== undefined;
+            const workspace = getSessionWorkspaceProperties(config.schema);
+            const properties = orderSessionConfigProperties(
+                Object.entries(config.schema.properties),
+                isPhoneLayout(this._layoutService)
+            ).filter(
+                ([property, schema]) => isRenderableSessionConfigProperty(property, schema, config.schema, isNewSession) && (isNewSession || schema.sessionMutable || property === workspace.isolation?.key || property === workspace.baseBranch?.key)
+            );
+            const branchIndex = properties.findIndex(([property]) => property === workspace.baseBranch?.key);
+            const isolationIndex = properties.findIndex(([property]) => property === workspace.isolation?.key);
+            const useExperimentalOrder = !isPhoneLayout(this._layoutService) && this._configurationService.getValue(EXPERIMENTAL_NEW_SESSION_COMPOSER_LAYOUT_SETTING) && this._configurationService.getValue(UNIFIED_WORKSPACE_PICKER_SETTING);
+            if (useExperimentalOrder && isolationIndex > branchIndex && branchIndex >= 0) {
+                [properties[branchIndex], properties[isolationIndex]] = [properties[isolationIndex], properties[branchIndex]];
+            }
+            properties.forEach(([property, schema], index) => {
+                const commandId = this._registerRepositoryProperty(property, actionViewItemService);
+                const order = index + 1;
+                this._repositoryMenuItems.add(MenuRegistry.appendMenuItem(Menus.NewSessionRepositoryConfig, {
+                    command: {
+                        id: commandId,
+                        title: schema.title ?? property
+                    },
+                    group: getNewSessionRepositoryConfigGroup(order, commandId),
+                    order,
+                    when: ( ContextKeyExpr.and(ChatContextKeys.enabled, ( IsQuickChatSessionContext.negate()), ( SessionIdContext.isEqualTo(session.sessionId))))
+                }));
+            });
+        }
+    }
+    _registerRepositoryProperty(property, actionViewItemService) {
+        const commandId = `${AGENT_HOST_SESSION_CONFIG_PICKER_ID_PREFIX}.${encodeURIComponent(property)}`;
+        if (( this._repositoryPropertyRegistrations.has(commandId))) {
+            return commandId;
+        }
+        const store = ( new DisposableStore());
+        store.add(CommandsRegistry.registerCommand(commandId, () => {}));
+        store.add(actionViewItemService.register(
+            Menus.NewSessionRepositoryConfig,
+            commandId,
+            (_action, _options, scopedInstantiationService) => {
+                const {
+                    session
+                } = scopedInstantiationService.invokeFunction(accessor => accessor.get(ISessionContext));
+                return ( new PickerActionViewItem(
+                    scopedInstantiationService.createInstance(MobileAgentHostSessionConfigPicker, session, property),
+                    undefined,
+                    true
+                ));
+            }
+        ));
+        this._repositoryPropertyRegistrations.set(commandId, store);
+        return commandId;
+    }
+    _createNewSessionPermissionPicker(instantiationService) {
+        const {
+            session
+        } = instantiationService.invokeFunction(accessor => accessor.get(ISessionContext));
+        const delegate = instantiationService.createInstance(AgentHostPermissionPickerDelegate, session);
+        const picker = instantiationService.createInstance(MobilePermissionPicker, delegate);
+        return ( new PickerActionViewItem(picker, delegate));
+    }
+    _createRunningSessionPermissionPickerFactory() {
+        return (action, _options, instantiationService) => {
+            if (!(action instanceof MenuItemAction)) {
+                return undefined;
+            }
+            const {
+                session
+            } = instantiationService.invokeFunction(accessor => accessor.get(ISessionContext));
+            const pickerOptions = {
+                compact: observableValue(action, false),
+                listOptions: {
+                    minWidth: 255
+                }
+            };
+            return instantiationService.createInstance(AgentHostPermissionPickerActionItem, action, pickerOptions, session);
+        };
+    }
+};
+AgentHostSessionConfigPickerContribution = ( __decorate([( __param(0, IActionViewItemService)), ( __param(1, IWorkbenchLayoutService)), ( __param(2, IContextKeyService)), ( __param(3, ISessionsProvidersService)), ( __param(4, ISessionsService)), ( __param(5, IConfigurationService))], AgentHostSessionConfigPickerContribution));
+const NEW_SESSION_APPROVE_PICKER_ID = "sessions.agentHost.newSessionApprovePicker";
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: NEW_SESSION_APPROVE_PICKER_ID,
+            title: ( localize2(4900, "Session Approvals")),
+            f1: false,
+            menu: [{
+                id: Menus.NewSessionControl,
+                group: "navigation",
+                order: 1,
+                when: ( ContextKeyExpr.or(IsActiveSessionLocalAgentHost, IsActiveSessionRemoteAgentHost))
+            }]
+        });
+    }
+    async run() {}
+});
+const NEW_SESSION_PERMISSION_MODE_PICKER_ID = "sessions.agentHost.newSessionPermissionModePicker";
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: NEW_SESSION_PERMISSION_MODE_PICKER_ID,
+            title: ( localize2(4901, "Approvals")),
+            f1: false,
+            menu: [{
+                id: Menus.NewSessionControl,
+                group: "navigation",
+                order: 2,
+                when: ( ContextKeyExpr.or(IsActiveSessionLocalAgentHost, IsActiveSessionRemoteAgentHost))
+            }]
+        });
+    }
+    async run() {}
+});
+const NEW_SESSION_CODEX_APPROVALS_PICKER_ID = "sessions.agentHost.newSessionCodexApprovalsPicker";
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: NEW_SESSION_CODEX_APPROVALS_PICKER_ID,
+            title: ( localize2(4902, "Approvals")),
+            f1: false,
+            menu: [{
+                id: Menus.NewSessionControl,
+                group: "navigation",
+                order: 3,
+                when: ( ContextKeyExpr.or(IsActiveSessionLocalAgentHost, IsActiveSessionRemoteAgentHost))
+            }]
+        });
+    }
+    async run() {}
+});
+const NEW_SESSION_MODE_PICKER_ID = "sessions.agentHost.newSessionModePicker";
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: NEW_SESSION_MODE_PICKER_ID,
+            title: ( localize2(4903, "Agent Mode")),
+            f1: false,
+            menu: [{
+                id: Menus.NewSessionControl,
+                group: "navigation",
+                order: 0,
+                when: ( ContextKeyExpr.and(( ContextKeyExpr.or(IsActiveSessionLocalAgentHost, IsActiveSessionRemoteAgentHost)), ( IsPhoneLayoutContext.negate())))
+            }]
+        });
+    }
+    async run() {}
+});
+const RUNNING_SESSION_CONFIG_PICKER_ID = "sessions.agentHost.runningSessionConfigPicker";
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: RUNNING_SESSION_CONFIG_PICKER_ID,
+            title: ( localize2(4904, "Session Approvals")),
+            f1: false,
+            menu: [{
+                id: MenuId.ChatInput,
+                group: "navigation",
+                order: 0.2,
+                when: ( ContextKeyExpr.and(ChatContextKeyExprs.isAgentHostSession, ExperimentalSessionComposerLayout))
+            }, {
+                id: MenuId.ChatInputSecondary,
+                group: "navigation",
+                order: 10,
+                when: ( ContextKeyExpr.and(ChatContextKeyExprs.isAgentHostSession, LegacySessionComposerLayout))
+            }]
+        });
+    }
+    async run() {}
+});
+const RUNNING_SESSION_PERMISSION_MODE_PICKER_ID = "sessions.agentHost.runningSessionPermissionModePicker";
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: RUNNING_SESSION_PERMISSION_MODE_PICKER_ID,
+            title: ( localize2(4905, "Approvals")),
+            f1: false,
+            menu: [{
+                id: MenuId.ChatInput,
+                group: "navigation",
+                order: 0.3,
+                when: ( ContextKeyExpr.and(ChatContextKeyExprs.isAgentHostSession, ExperimentalSessionComposerLayout))
+            }, {
+                id: MenuId.ChatInputSecondary,
+                group: "navigation",
+                order: 11,
+                when: ( ContextKeyExpr.and(ChatContextKeyExprs.isAgentHostSession, LegacySessionComposerLayout))
+            }]
+        });
+    }
+    async run() {}
+});
+const RUNNING_SESSION_CODEX_APPROVALS_PICKER_ID = "sessions.agentHost.runningSessionCodexApprovalsPicker";
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: RUNNING_SESSION_CODEX_APPROVALS_PICKER_ID,
+            title: ( localize2(4906, "Approvals")),
+            f1: false,
+            menu: [{
+                id: MenuId.ChatInput,
+                group: "navigation",
+                order: 0.4,
+                when: ( ContextKeyExpr.and(ChatContextKeyExprs.isAgentHostSession, ExperimentalSessionComposerLayout))
+            }, {
+                id: MenuId.ChatInputSecondary,
+                group: "navigation",
+                order: 12,
+                when: ( ContextKeyExpr.and(ChatContextKeyExprs.isAgentHostSession, LegacySessionComposerLayout))
+            }]
+        });
+    }
+    async run() {}
+});
+const RUNNING_SESSION_MODE_PICKER_ID = "sessions.agentHost.runningSessionModePicker";
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: RUNNING_SESSION_MODE_PICKER_ID,
+            title: ( localize2(4907, "Agent Mode")),
+            f1: false,
+            menu: [{
+                id: MenuId.ChatInput,
+                group: "navigation",
+                order: 0.1,
+                when: ( ContextKeyExpr.and(ChatContextKeyExprs.isAgentHostSession, ( ChatContextKeys.hasPendingDelegationTarget.negate()), ExperimentalSessionComposerLayout))
+            }, {
+                id: MenuId.ChatInputSecondary,
+                group: "navigation",
+                order: 9,
+                when: ( ContextKeyExpr.and(ChatContextKeyExprs.isAgentHostSession, ( ChatContextKeys.hasPendingDelegationTarget.negate()), LegacySessionComposerLayout))
+            }]
+        });
+    }
+    async run(accessor) {
+        showActiveSessionModePicker(accessor);
+    }
+});
+registerWorkbenchContribution2(
+    AgentHostSessionConfigPickerContribution.ID,
+    AgentHostSessionConfigPickerContribution,
+    WorkbenchPhase.AfterRestored
+);
+
+export { AgentHostSessionConfigPicker, AgentHostSessionConfigPickerContribution, PickerActionViewItem, getConfigIcon };