@codingame/monaco-vscode-workbench-service-override 37.3.2 → 37.3.4

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

@@ -0,0 +1,1390 @@
+
+import { registerCss } from '@codingame/monaco-vscode-api/css';
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import * as agentHostSessionConfigPicker from './media/agentHostSessionConfigPicker.css';
+import { getActiveElement, isHTMLElement, getActiveDocument, append, $, EventType, addDisposableListener, EventHelper, clearNode, isAncestorOfActiveElement, isAncestor, isActiveElement } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { Gesture, EventType as EventType$1 } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/touch';
+import { renderIcon } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/iconLabel/iconLabels';
+import { ActionListItemKind } from '@codingame/monaco-vscode-api/vscode/vs/platform/actionWidget/browser/actionList';
+import { IActionWidgetService } from '@codingame/monaco-vscode-api/vscode/vs/platform/actionWidget/browser/actionWidget.service';
+import { BaseActionViewItem } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/actionbar/actionViewItems';
+import { Checkbox } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/toggle/toggle';
+import { toAction } from '@codingame/monaco-vscode-api/vscode/vs/base/common/actions';
+import { Delayer, SequencerByKey } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
+import { Disposable, MutableDisposable, DisposableStore, DisposableMap, toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { ThemeIcon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/themables';
+import { localize2, localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { IActionViewItemService } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/browser/actionViewItemService.service';
+import { registerAction2, Action2, MenuId, MenuItemAction } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { ContextKeyExpr } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey';
+import { IContextKeyService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service';
+import { IDialogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/dialogs/common/dialogs.service';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { IHoverService } from '@codingame/monaco-vscode-api/vscode/vs/platform/hover/browser/hover.service';
+import { ITelemetryService } from '@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service';
+import { IStorageService } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service';
+import { defaultCheckboxStyles } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/browser/defaultStyles';
+import { ChatConfiguration, isChatPermissionLevel } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
+import { maybeConfirmElevatedPermissionLevel } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatPermissionWarnings';
+import { ChatContextKeyExprs, ChatContextKeys } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/actions/chatContextKeys';
+import { markOnboardingTarget } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/onboarding/browser/spotlight/onboardingTarget';
+import { registerWorkbenchContribution2, WorkbenchPhase } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions';
+import { IViewsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/views/common/viewsService.service';
+import { IAgentWorkbenchLayoutService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/browser/workbench.service';
+import { Menus } from '@codingame/monaco-vscode-api/vscode/vs/sessions/browser/menus';
+import { DevContainerWorktreeEnabledSettingId } from '@codingame/monaco-vscode-api/vscode/vs/sessions/common/devContainerAgentHostService';
+import { SessionProviderIdContext, IsQuickChatSessionContext, IsPhoneLayoutContext } from '@codingame/monaco-vscode-api/vscode/vs/sessions/common/contextkeys';
+import { IWorkbenchLayoutService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/layout/browser/layoutService.service';
+import { reportNewChatPickerClosed } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/chat/browser/newChatPickerTelemetry';
+import '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/changes/browser/sessionChangesService';
+import { CHANGES_VIEW_ID } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/changes/common/changes';
+import { ISessionsProvidersService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsProvidersService.service';
+import { ISessionContext } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionContext.service';
+import { ISessionsService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsService.service';
+import { REMOTE_AGENT_HOST_PROVIDER_RE, LOCAL_AGENT_HOST_PROVIDER_ID, isAgentHostProvider } from '@codingame/monaco-vscode-api/vscode/vs/sessions/common/agentHostSessionsProvider';
+import { MobilePermissionPicker } from '@codingame/monaco-vscode-katex-common/vscode/vs/sessions/contrib/providers/copilotChatSessions/browser/mobilePermissionPicker';
+import { isPhoneLayout } from '@codingame/monaco-vscode-api/vscode/vs/sessions/browser/parts/mobile/mobileLayout';
+import { showMobilePickerSheet, MOBILE_PICKER_SHEET_CONFIRM } from '@codingame/monaco-vscode-api/vscode/vs/sessions/browser/parts/mobile/mobilePickerSheet';
+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 '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/sessionConfigKeys';
+import { AGENT_HOST_CHECKOUT_CHANGESET_OPERATION_ID } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostChangesetOperationService';
+import { checkoutOperationMeta, isCheckoutOperationDirtyWorkingTreeErrorData, CheckoutOperationPreAction } from '../../../../../platform/agentHost/common/meta/agentCheckoutOperationMeta.js';
+import { ProtocolError } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/sessionProtocol';
+import { AgentHostClaudePermissionModePicker } from './agentHostClaudePermissionModePicker.js';
+import { ClaudeSessionConfigKey } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/claudeSessionConfigKeys';
+import { AgentHostCodexApprovalsPicker } from './agentHostCodexApprovalsPicker.js';
+import { isAutoApproveValuePolicyRestricted } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/agentHostConfigPolicy';
+import { CodexSessionConfigKey } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/codexSessionConfigKeys';
+import { UNCOMMITTED_CHANGES_CHANGESET_ID } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/session';
+import { MarkdownString } from '@codingame/monaco-vscode-api/vscode/vs/base/common/htmlContent';
+import { observableValue } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableValue';
+import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
+import { isWellKnownAutoApproveSchema, isWellKnownModeSchema } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentHost/agentHostModePickerPresentation';
+import { ISessionChangesService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/changes/common/sessionChangesService.service';
+
+registerCss(agentHostSessionConfigPicker, 1);
+const IsActiveSessionRemoteAgentHost = ( ContextKeyExpr.regex(SessionProviderIdContext.key, REMOTE_AGENT_HOST_PROVIDER_RE));
+const IsActiveSessionLocalAgentHost = ( ContextKeyExpr.equals(SessionProviderIdContext.key, LOCAL_AGENT_HOST_PROVIDER_ID));
+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();
+    }
+}
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: "sessions.agentHost.sessionConfigPicker",
+            title: ( localize2(4212, "Session Configuration")),
+            f1: false,
+            menu: [{
+                id: Menus.NewSessionRepositoryConfig,
+                group: "navigation",
+                order: 3,
+                when: ( ContextKeyExpr.and(( ContextKeyExpr.or(IsActiveSessionLocalAgentHost, IsActiveSessionRemoteAgentHost)), ( IsQuickChatSessionContext.negate())))
+            }]
+        });
+    }
+    async run() {}
+});
+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(4213, "1 uncommitted file")) : ( localize(4214, "{0} uncommitted files", count));
+}
+function getBranchUncommittedChanges(branchName, repositoryBranchName, repositoryUncommittedChanges) {
+    return branchName === repositoryBranchName && (repositoryUncommittedChanges ?? 0) > 0 ? repositoryUncommittedChanges : undefined;
+}
+function toActionItems(
+    property,
+    items,
+    currentValue,
+    policyRestricted,
+    repositoryBranchName,
+    repositoryUncommittedChanges,
+    onShowChanges
+) {
+    const actionItems = items.map(item => {
+        const disabled = property === SessionConfigKey.AutoApprove && isAutoApproveValuePolicyRestricted(item.value, policyRestricted === true);
+        const checked = isSelectedValue(currentValue, item.value);
+        const uncommittedChanges = property === SessionConfigKey.Branch ? getBranchUncommittedChanges(item.value, repositoryBranchName, repositoryUncommittedChanges) : undefined;
+        const uncommittedChangesDescription = uncommittedChanges !== undefined ? formatUncommittedChanges(uncommittedChanges) : undefined;
+        return {
+            kind: ActionListItemKind.Action,
+            label: item.label,
+            detail: disabled ? ( localize(4215, "Disabled by your organization. Contact your administrator.")) : uncommittedChangesDescription ?? item.description,
+            group: {
+                title: "",
+                icon: getConfigIcon(property, item.value, uncommittedChanges !== undefined)
+            },
+            ariaDescription: uncommittedChangesDescription,
+            disabled,
+            item: {
+                ...item,
+                checked
+            },
+            toolbarActions: property === SessionConfigKey.Branch && item.value === repositoryBranchName && onShowChanges ? [toAction({
+                id: "sessions.agentHost.showBranchChanges",
+                label: ( localize(4216, "Show Changes")),
+                class: ThemeIcon.asClassName(Codicon.diffMultiple),
+                run: onShowChanges
+            })] : undefined
+        };
+    });
+    if (property === SessionConfigKey.Branch) {
+        const currentIndex = actionItems.findIndex(item => item.item?.checked);
+        if (currentIndex >= 0) {
+            const [current] = actionItems.splice(currentIndex, 1);
+            actionItems.unshift(current);
+            if (actionItems.length > 1) {
+                actionItems.splice(1, 0, {
+                    kind: ActionListItemKind.Separator,
+                    label: ""
+                });
+            }
+        }
+    }
+    return actionItems;
+}
+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");
+        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
+    };
+}
+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(4217, "{0}: {1}, Uncommitted Files, Read-Only", title, label)) : ( localize(4218, "{0}: {1}, Uncommitted Files", title, label));
+    }
+    return isReadOnly ? ( localize(4219, "{0}: {1}, Read-Only", title, label)) : ( localize(4220, "{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,
+        _actionWidgetService,
+        _configurationService,
+        _contextKeyService,
+        _dialogService,
+        _hoverService,
+        _sessionsProvidersService,
+        _telemetryService,
+        _layoutService,
+        _storageService,
+        _sessionChangesService,
+        _viewsService
+    ) {
+        super();
+        this._session = _session;
+        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._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._repositoryConfigSequencer = ( new SequencerByKey());
+        this._dynamicValueLabels = ( new Map());
+        this._register(autorun(reader => {
+            const session = this._session.read(reader);
+            for (const changeset of session?.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();
+            }
+        }));
+    }
+    _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();
+    }
+    _renderConfigPickers() {
+        if (!this._container) {
+            return;
+        }
+        this._renderDisposables.clear();
+        const checkboxSlots = ( new Set([this._isolationCheckbox.value?.slot]));
+        for (const child of Array.from(this._container.children)) {
+            if (!( checkboxSlots.has(child))) {
+                child.remove();
+            }
+        }
+        const session = this._session.get();
+        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._isPickable(schema)) {
+                continue;
+            }
+            if (property === SessionConfigKey.SandboxEnabled) {
+                continue;
+            }
+            if (property === SessionConfigKey.WorktreeBranchTrack || property === SessionConfigKey.WorktreeCreateNewBranch) {
+                continue;
+            }
+            if (property === SessionConfigKey.Isolation && !schema.enum?.includes("worktree")) {
+                continue;
+            }
+            if (!this._shouldRenderProperty(property, schema, isNewSession)) {
+                continue;
+            }
+            if (property === SessionConfigKey.AutoApprove && isWellKnownAutoApproveSchema(schema)) {
+                continue;
+            }
+            if (property === SessionConfigKey.Mode && isWellKnownModeSchema(schema)) {
+                continue;
+            }
+            if (property === ClaudeSessionConfigKey.PermissionMode && isWellKnownClaudePermissionModeSchema(schema)) {
+                continue;
+            }
+            if (property === CodexSessionConfigKey.PermissionsPreset && isWellKnownCodexApprovalsSchema(schema)) {
+                continue;
+            }
+            const value = resolvedConfig.values[property] ?? schema.default;
+            const isReadOnly = this._isReadOnlyChip(property, schema, isNewSession) || (this._requiresBranchCheckout(provider, session.sessionId, property) && !this._getCheckoutChangeset(session.sessionId));
+            if (property === SessionConfigKey.Isolation && this._shouldRenderIsolationAsCheckbox(schema)) {
+                this._renderIsolationCheckbox(
+                    provider,
+                    session.sessionId,
+                    schema,
+                    value,
+                    isReadOnly,
+                    !isReadOnly && isLoading
+                );
+                renderedIsolationCheckbox = true;
+                continue;
+            }
+            const slot = append(this._container, $(".sessions-chat-picker-slot"));
+            if (property === SessionConfigKey.Isolation) {
+                this._renderDisposables.add(markOnboardingTarget(slot, "sessions.newSession.isolation"));
+            }
+            const trigger = renderPickerTrigger(
+                slot,
+                isReadOnly,
+                this._renderDisposables,
+                () => this._showPicker(provider, session.sessionId, property, schema, trigger)
+            );
+            const tooltip = property !== 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();
+        }
+    }
+    _isPickable(schema) {
+        if (schema.type === "boolean") {
+            return true;
+        }
+        if (schema.type !== "string") {
+            return false;
+        }
+        return !!schema.enumDynamic || (Array.isArray(schema.enum) && schema.enum.length > 0);
+    }
+    _orderProperties(properties) {
+        const order = ( new Map([[SessionConfigKey.Isolation, 0], [SessionConfigKey.Branch, 1]]));
+        return properties.map(([key, schema], index) => ({
+            key,
+            schema,
+            index
+        })).sort((a, b) => {
+            const aRank = order.get(a.key) ?? Number.MAX_SAFE_INTEGER;
+            const bRank = order.get(b.key) ?? Number.MAX_SAFE_INTEGER;
+            return aRank - bRank || a.index - b.index;
+        }).map((
+            {
+                key,
+                schema
+            }
+        ) => [key, schema]);
+    }
+    _shouldRenderProperty(property, schema, isNewSession) {
+        return isNewSession || !!schema.sessionMutable;
+    }
+    _isReadOnlyChip(property, schema, isNewSession) {
+        return !!schema.readOnly;
+    }
+    async _setSessionConfigValue(provider, sessionId, property, value) {
+        const isDraftRepositoryProperty = provider.getCreateSessionConfig(sessionId) !== undefined && (property === SessionConfigKey.Isolation || property === SessionConfigKey.Branch);
+        if (!isDraftRepositoryProperty) {
+            await provider.setSessionConfigValue(sessionId, property, value);
+            return;
+        }
+        let treeish;
+        if (property === SessionConfigKey.Branch) {
+            if (typeof value !== "string" || value.length === 0) {
+                throw ( new Error("Branch configuration values must be non-empty strings."));
+            }
+            treeish = value;
+        }
+        const configOperation = this._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(
+                4221,
+                "Your local changes would be overwritten when checking out '{0}'.",
+                treeish
+            )),
+            detail: ( new MarkdownString(errorMessage)),
+            buttons: [{
+                label: ( localize(4222, "Stash & Checkout")),
+                run: () => CheckoutOperationPreAction.Stash
+            }, {
+                label: ( localize(4223, "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) {
+        return property === SessionConfigKey.Branch && 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.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 icon = getConfigIcon(property, 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 (property === 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(4224, "{0}, {1} uncommitted file", branchName, uncommittedChanges)) : ( localize(4225, "{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");
+    }
+    _renderIsolationCheckbox(provider, sessionId, schema, value, isReadOnly, isLoading) {
+        const label = ( localize(4226, "New Worktree"));
+        const worktreeIndex = schema.enum?.indexOf("worktree") ?? -1;
+        const checked = value === "worktree";
+        const combinationDisabled = !this._isDevContainerWorktreeEnabled() && provider.isDevContainerEnabled?.(sessionId) === true && !checked;
+        const tooltip = combinationDisabled ? ( localize(4227, "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() {
+        return 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 schema = resolvedConfig?.schema.properties[SessionConfigKey.Isolation];
+        if (!provider || !schema) {
+            return;
+        }
+        const before = resolvedConfig.values[SessionConfigKey.Isolation] ?? schema.default;
+        const nextValue = checked ? "worktree" : "folder";
+        reportNewChatPickerClosed(this._telemetryService, {
+            id: "NewChatAgentHostSessionConfigPicker",
+            name: `NewChatAgentHostSessionConfigPicker.${SessionConfigKey.Isolation}`,
+            optionIdBefore: typeof before === "string" ? before : undefined,
+            optionIdAfter: nextValue,
+            optionLabelBefore: typeof before === "string" ? this._getLabel(sessionId, SessionConfigKey.Isolation, schema, before) : undefined,
+            optionLabelAfter: this._getLabel(sessionId, SessionConfigKey.Isolation, schema, nextValue),
+            isPII: false
+        });
+        this._setSessionConfigValue(provider, sessionId, SessionConfigKey.Isolation, nextValue).catch(() => {});
+    }
+    async _showPicker(provider, sessionId, property, schema, trigger) {
+        if (schema.readOnly || this._actionWidgetService.isVisible) {
+            return;
+        }
+        if (provider.isSessionConfigResolving(sessionId).get()) {
+            return;
+        }
+        const rawItems = await this._getItems(provider, sessionId, property, schema);
+        const {
+            items,
+            policyRestricted
+        } = applyAutoApproveFiltering(rawItems, property, this._configurationService);
+        if (items.length === 0) {
+            return;
+        }
+        const isAutoApproveProperty = property === SessionConfigKey.AutoApprove;
+        const currentValue = provider.getSessionConfig(sessionId)?.values[property] ?? schema.default;
+        const currentItem = items.find(i => isSelectedValue(currentValue, i.value));
+        const repositoryState = property === SessionConfigKey.Branch ? this._getRepositoryBranchState(sessionId) : undefined;
+        const onShowChanges = property === SessionConfigKey.Branch ? () => this._showChanges() : undefined;
+        const actionItems = toActionItems(
+            property,
+            items,
+            currentValue,
+            policyRestricted,
+            repositoryState?.branchName,
+            repositoryState?.uncommittedChanges,
+            onShowChanges
+        );
+        const delegate = {
+            onSelect: async item => {
+                this._actionWidgetService.hide();
+                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(() => {});
+            },
+            onFilter: schema.enumDynamic ? query => this._filterDelayer.trigger(async () => {
+                const filteredRawItems = await this._getItems(provider, sessionId, property, schema, query);
+                const {
+                    items: filteredItems,
+                    policyRestricted: filteredPolicyRestricted
+                } = applyAutoApproveFiltering(filteredRawItems, property, this._configurationService);
+                const filteredRepositoryState = this._getRepositoryBranchState(sessionId);
+                return toActionItems(
+                    property,
+                    filteredItems,
+                    provider.getSessionConfig(sessionId)?.values[property] ?? schema.default,
+                    filteredPolicyRestricted,
+                    filteredRepositoryState.branchName,
+                    filteredRepositoryState.uncommittedChanges,
+                    onShowChanges
+                );
+            }) : undefined,
+            onHide: () => {
+                trigger.focus();
+            }
+        };
+        this._actionWidgetService.show(
+            `agentHostSessionConfig.${property}`,
+            false,
+            actionItems,
+            delegate,
+            trigger,
+            undefined,
+            [],
+            {
+                getAriaLabel: item => item.ariaDescription ? ( localize(4228, "{0}, {1}", item.label ?? "", item.ariaDescription)) : item.label ?? "",
+                getWidgetAriaLabel: () => ( localize(4229, "{0} Picker", schema.title))
+            },
+            items.length > 10 ? {
+                showFilter: true,
+                filterPlaceholder: ( localize(4230, "Filter options...")),
+                minWidth: 255
+            } : {
+                minWidth: 255
+            }
+        );
+    }
+    async _showChanges() {
+        this._actionWidgetService.hide();
+        const session = this._session.get();
+        if (this._layoutService.isSinglePaneLayoutEnabled && 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,
+            uncommittedChanges: repository?.uncommittedChanges
+        };
+    }
+    async _getItems(provider, sessionId, property, schema, query) {
+        if (schema.type === "boolean") {
+            return [{
+                value: "true",
+                label: ( localize(4231, "On"))
+            }, {
+                value: "false",
+                label: ( localize(4232, "Off"))
+            }];
+        }
+        const dynamicItems = schema.enumDynamic ? await provider.getSessionConfigCompletions(sessionId, property, query) : undefined;
+        if (dynamicItems?.length) {
+            const items = 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 (schema.type === "boolean") {
+            return value === true ? ( localize(4233, "On")) : ( localize(4234, "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;
+    }
+    _getProvider(providerId) {
+        const provider = this._sessionsProvidersService.getProvider(providerId);
+        return provider && isAgentHostProvider(provider) ? provider : undefined;
+    }
+};
+AgentHostSessionConfigPicker = ( __decorate([( __param(1, IActionWidgetService)), ( __param(2, IConfigurationService)), ( __param(3, IContextKeyService)), ( __param(4, IDialogService)), ( __param(5, IHoverService)), ( __param(6, ISessionsProvidersService)), ( __param(7, ITelemetryService)), ( __param(8, IAgentWorkbenchLayoutService)), ( __param(9, IStorageService)), ( __param(10, ISessionChangesService)), ( __param(11, IViewsService))], AgentHostSessionConfigPicker));
+class MobileAgentHostSessionConfigPicker extends AgentHostSessionConfigPicker {
+    _orderProperties(properties) {
+        if (!isPhoneLayout(this._layoutService)) {
+            return super._orderProperties(properties);
+        }
+        const order = ( new Map([[SessionConfigKey.Branch, 0], [SessionConfigKey.Isolation, 1]]));
+        return properties.slice().sort(([aKey], [bKey]) => {
+            const a = order.get(aKey) ?? Number.MAX_SAFE_INTEGER;
+            const b = order.get(bKey) ?? Number.MAX_SAFE_INTEGER;
+            return a - b;
+        });
+    }
+    _shouldRenderProperty(property, schema, isNewSession) {
+        const isUnifiedRepoProperty = property === SessionConfigKey.Isolation || property === 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;
+        }
+        if (property === SessionConfigKey.Isolation || property === SessionConfigKey.Branch) {
+            await this._showUnifiedRepoSheet(provider, sessionId, trigger);
+            return;
+        }
+        return super._showPicker(provider, sessionId, property, schema, trigger);
+    }
+    async _showUnifiedRepoSheet(provider, sessionId, trigger) {
+        const config = provider.getSessionConfig(sessionId);
+        if (!config) {
+            return;
+        }
+        const isolationSchema = config.schema.properties[SessionConfigKey.Isolation];
+        const branchSchema = config.schema.properties[SessionConfigKey.Branch];
+        const canSelectBranch = !this._requiresBranchCheckout(provider, sessionId, SessionConfigKey.Branch) || !!this._getCheckoutChangeset(sessionId);
+        const [isolationItems, branchItems] = await Promise.all([
+            isolationSchema && !isolationSchema.readOnly ? this._getItems(provider, sessionId, SessionConfigKey.Isolation, isolationSchema) : Promise.resolve([]),
+            branchSchema && !branchSchema.readOnly && canSelectBranch ? this._getItems(provider, sessionId, SessionConfigKey.Branch, branchSchema) : Promise.resolve([])
+        ]);
+        const isolationValue = config.values[SessionConfigKey.Isolation];
+        const branchValue = config.values[SessionConfigKey.Branch];
+        const repositoryState = this._getRepositoryBranchState(sessionId);
+        const sheetItems = [];
+        const idToConfig = ( new Map());
+        const registerId = (property, value, label, isPII) => {
+            const id = `repo-row-${idToConfig.size}`;
+            idToConfig.set(id, {
+                property,
+                value,
+                label,
+                isPII
+            });
+            return id;
+        };
+        isolationItems.forEach((item, index) => {
+            sheetItems.push({
+                id: registerId(
+                    SessionConfigKey.Isolation,
+                    item.value,
+                    item.label,
+                    !!isolationSchema?.enumDynamic
+                ),
+                label: item.label,
+                description: item.description,
+                icon: getConfigIcon(SessionConfigKey.Isolation, item.value),
+                checked: item.value === isolationValue,
+                sectionTitle: index === 0 ? (isolationSchema?.title ?? ( localize(4235, "Isolation"))) : undefined
+            });
+        });
+        const branchSectionTitle = branchSchema?.title ?? ( localize(4236, "Base Branch"));
+        if (!branchSchema?.enumDynamic) {
+            branchItems.forEach((item, index) => {
+                const uncommittedChanges = getBranchUncommittedChanges(item.value, repositoryState.branchName, repositoryState.uncommittedChanges);
+                sheetItems.push({
+                    id: registerId(
+                        SessionConfigKey.Branch,
+                        item.value,
+                        item.label,
+                        !!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 && !branchSchema.readOnly && canSelectBranch) {
+            search = {
+                placeholder: ( localize(4237, "Search branches")),
+                ariaLabel: ( localize(4238, "Search base branches")),
+                resultsSectionTitle: branchSectionTitle,
+                emptyMessage: ( localize(4239, "No matching branches.")),
+                loadItems: async (query, token) => {
+                    const items = query ? await this._getItems(provider, sessionId, SessionConfigKey.Branch, branchSchema, query) : branchItems;
+                    if (token.isCancellationRequested) {
+                        return [];
+                    }
+                    return items.map(item => {
+                        const uncommittedChanges = getBranchUncommittedChanges(item.value, repositoryState.branchName, repositoryState.uncommittedChanges);
+                        return {
+                            id: registerId(
+                                SessionConfigKey.Branch,
+                                item.value,
+                                item.label,
+                                !!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(4240, "Worktree")), sheetItems, {
+            search,
+            stayOpenOnSelect: true,
+            onDidSelect: id => {
+                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(() => {});
+                    if (selection.property === SessionConfigKey.Isolation) {
+                        return MOBILE_PICKER_SHEET_CONFIRM;
+                    }
+                }
+                return undefined;
+            }
+        });
+        trigger.setAttribute("aria-expanded", "false");
+        trigger.focus();
+    }
+}
+class PickerActionViewItem extends BaseActionViewItem {
+    constructor(_picker, disposable) {
+        super(undefined, {
+            id: "",
+            label: "",
+            enabled: true,
+            class: undefined,
+            tooltip: "",
+            run: () => {}
+        });
+        this._picker = _picker;
+        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._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() {
+        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;
+        }
+    }
+    _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) {
+        super();
+        this._layoutService = _layoutService;
+        this._register(actionViewItemService.register(
+            Menus.NewSessionRepositoryConfig,
+            "sessions.agentHost.sessionConfigPicker",
+            (_action, _options, scopedInstantiationService) => {
+                const {
+                    session
+                } = scopedInstantiationService.invokeFunction(accessor => accessor.get(ISessionContext));
+                return ( new PickerActionViewItem(
+                    scopedInstantiationService.createInstance(MobileAgentHostSessionConfigPicker, session)
+                ));
+            }
+        ));
+        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
+                )));
+            }
+        ));
+        this._register(actionViewItemService.register(
+            MenuId.ChatInputSecondary,
+            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)
+                ));
+            }
+        ));
+        this._register(actionViewItemService.register(
+            MenuId.ChatInputSecondary,
+            RUNNING_SESSION_CONFIG_PICKER_ID,
+            this._createRunningSessionPermissionPickerFactory()
+        ));
+        this._register(actionViewItemService.register(
+            MenuId.ChatInputSecondary,
+            RUNNING_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(
+            MenuId.ChatInputSecondary,
+            RUNNING_SESSION_CODEX_APPROVALS_PICKER_ID,
+            (_action, _options, scopedInstantiationService) => {
+                const {
+                    session
+                } = scopedInstantiationService.invokeFunction(accessor => accessor.get(ISessionContext));
+                return ( new PickerActionViewItem(
+                    scopedInstantiationService.createInstance(AgentHostCodexApprovalsPicker, session)
+                ));
+            }
+        ));
+    }
+    _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))], AgentHostSessionConfigPickerContribution));
+const NEW_SESSION_APPROVE_PICKER_ID = "sessions.agentHost.newSessionApprovePicker";
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: NEW_SESSION_APPROVE_PICKER_ID,
+            title: ( localize2(4241, "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(4242, "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(4243, "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(4244, "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(4245, "Session Approvals")),
+            f1: false,
+            menu: [{
+                id: MenuId.ChatInputSecondary,
+                group: "navigation",
+                order: 10,
+                when: ChatContextKeyExprs.isAgentHostSession
+            }]
+        });
+    }
+    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(4246, "Approvals")),
+            f1: false,
+            menu: [{
+                id: MenuId.ChatInputSecondary,
+                group: "navigation",
+                order: 11,
+                when: ChatContextKeyExprs.isAgentHostSession
+            }]
+        });
+    }
+    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(4247, "Approvals")),
+            f1: false,
+            menu: [{
+                id: MenuId.ChatInputSecondary,
+                group: "navigation",
+                order: 12,
+                when: ChatContextKeyExprs.isAgentHostSession
+            }]
+        });
+    }
+    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(4248, "Agent Mode")),
+            f1: false,
+            menu: [{
+                id: MenuId.ChatInputSecondary,
+                group: "navigation",
+                order: 9,
+                when: ( ContextKeyExpr.and(ChatContextKeyExprs.isAgentHostSession, ( ChatContextKeys.hasPendingDelegationTarget.negate())))
+            }]
+        });
+    }
+    async run(accessor) {
+        showActiveSessionModePicker(accessor);
+    }
+});
+registerWorkbenchContribution2(
+    AgentHostSessionConfigPickerContribution.ID,
+    AgentHostSessionConfigPickerContribution,
+    WorkbenchPhase.AfterRestored
+);
+
+export { AgentHostSessionConfigPicker, PickerActionViewItem, getConfigIcon };