@codingame/monaco-vscode-api 37.2.0 → 37.3.1

package/vscode/src/vs/workbench/contrib/chat/browser/agentSessions/agentHost/agentHostChatInputPicker.js

@@ -0,0 +1,1053 @@
+
+import { registerCss } from '../../../../../../../../../css.js';
+import { __decorate, __param } from '../../../../../../../../../external/tslib/tslib.es6.js';
+import * as agentHostChatInputPicker from './media/agentHostChatInputPicker.css';
+import { append, $, EventType, addDisposableListener, EventHelper, clearNode } 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 { BaseActionViewItem } from '../../../../../../base/browser/ui/actionbar/actionViewItems.js';
+import { Delayer } from '../../../../../../base/common/async.js';
+import { CancellationTokenSource } from '../../../../../../base/common/cancellation.js';
+import { Codicon } from '../../../../../../base/common/codicons.js';
+import { onUnexpectedError } from '../../../../../../base/common/errors.js';
+import { Disposable, DisposableStore, MutableDisposable, toDisposable } from '../../../../../../base/common/lifecycle.js';
+import '../../../../../../base/common/observableInternal/index.js';
+import { OperatingSystem } from '../../../../../../base/common/platform.js';
+import { isEqual } from '../../../../../../base/common/resources.js';
+import { hasKey } from '../../../../../../base/common/types.js';
+import { URI } from '../../../../../../base/common/uri.js';
+import { localize } from '../../../../../../nls.js';
+import { ActionListItemKind } from '../../../../../../platform/actionWidget/browser/actionList.js';
+import { IActionWidgetService } from '../../../../../../platform/actionWidget/browser/actionWidget.service.js';
+import { getCodexApprovalsPickerListOptions } from '../../../../../../platform/agentHost/browser/codexApprovalsPicker.js';
+import { equalsAgentHostSandboxTogglePresentation, getAgentHostSandboxToggleState, createAgentHostSandboxToggle } from '../../../../../../platform/agentHost/browser/agentHostSandboxToggle.js';
+import { IAgentHostEnablementService } from '../../../../../../platform/agentHost/common/agentHostEnablementService.service.js';
+import { getAgentHostOperatingSystem } from '../../../../../../platform/agentHost/common/agentHostOperatingSystem.js';
+import { getAgentHostCopilotSandboxSettingId } from '../../../../../../platform/agentHost/common/agentService.js';
+import { IAgentHostService } from '../../../../../../platform/agentHost/common/agentService.service.js';
+import { AgentHostCustomTerminalToolEnabledSettingId } from '../../../../../../platform/agentHost/common/copilotCliConfig.js';
+import { SessionConfigKey } from '../../../../../../platform/agentHost/common/sessionConfigKeys.js';
+import { ClaudeSessionConfigKey } from '../../../../../../platform/agentHost/common/claudeSessionConfigKeys.js';
+import { CodexSessionConfigKey } from '../../../../../../platform/agentHost/common/codexSessionConfigKeys.js';
+import { ActionType } from '../../../../../../platform/agentHost/common/state/protocol/common/actions.js';
+import { StateComponents } from '../../../../../../platform/agentHost/common/state/sessionState.js';
+import { IHoverService } from '../../../../../../platform/hover/browser/hover.service.js';
+import { ILogService } from '../../../../../../platform/log/common/log.service.js';
+import { IOpenerService } from '../../../../../../platform/opener/common/opener.service.js';
+import { IDialogService } from '../../../../../../platform/dialogs/common/dialogs.service.js';
+import { IStorageService } from '../../../../../../platform/storage/common/storage.service.js';
+import { isAgentSandboxEnabledValue, AgentSandboxEnabledValue } from '../../../../../../platform/sandbox/common/settings.js';
+import { toAction } from '../../../../../../base/common/actions.js';
+import { IConfigurationService } from '../../../../../../platform/configuration/common/configuration.service.js';
+import { IWorkspaceContextService } from '../../../../../../platform/workspace/common/workspace.service.js';
+import { ChatPermissionLevel, ChatConfiguration, isChatPermissionLevel } from '../../../common/constants.js';
+import { SessionType } from '../../../common/chatSessionsService.js';
+import { isAutoApproveValuePolicyRestricted, isAutoApprovePolicyRestricted, isAssistedPermissionsEnabled, isPermissionLevelVisible, normalizeSessionConfigValue } from '../../../common/agentHostConfigPolicy.js';
+import { maybeConfirmElevatedPermissionLevel } from '../../../common/chatPermissionWarnings.js';
+import { isUntitledChatSession, getChatSessionType } from '../../../common/model/chatUri.js';
+import { withChatInputPickerMotion } from '../../widget/input/chatInputPickerActionItem.js';
+import { IAgentHostSessionWorkingDirectoryResolver } from './agentHostSessionWorkingDirectoryResolver.service.js';
+import { IAgentHostNewSessionFolderService } from './agentHostNewSessionFolderService.service.js';
+import { IAgentHostUntitledProvisionalSessionService } from './agentHostUntitledProvisionalSessionService.service.js';
+import { toAgentHostBackendSessionUri } from './agentHostSessionUri.js';
+import { getCompactCodicon } from '../../chatIcons.js';
+import { IChatPhoneInputPresenter } from '../../widget/input/chatPhoneInputPresenter.service.js';
+import { isWellKnownAutoApproveSchema, getModePickerAriaLabel, renderModePickerTrigger, shouldCombineModeAndPermissions, createModePickerModeItems, createModePickerPermissionsItems, AGENT_HOST_PERMISSIONS_SETTINGS_QUERY, MODE_PERMISSIONS_PICKER_OPEN_ATTRIBUTE, getModePermissionsPickerAccessibilityProvider, getModePermissionsPickerOptions } from './agentHostModePickerPresentation.js';
+import { IPreferencesService } from '../../../../../services/preferences/common/preferences.service.js';
+import { observableSignal } from '../../../../../../base/common/observableInternal/observables/observableSignal.js';
+import { autorun } from '../../../../../../base/common/observableInternal/reactions/autorun.js';
+
+registerCss(agentHostChatInputPicker, 1);
+const FILTER_THRESHOLD = 10;
+const LEARN_MORE_VALUE = "__agentHostChatInputPicker.learnMore__";
+const PERMISSIONS_LEARN_MORE_URL = "https://aka.ms/vscode/docs/permissions";
+const CODEX_APPROVALS_LEARN_MORE_URL = "https://developers.openai.com/codex/concepts/sandboxing#how-you-control-it";
+function getConfigIcon(property, value) {
+    if (property === SessionConfigKey.Mode) {
+        switch (value) {
+        case "plan":
+            return Codicon.checklist;
+        case "autopilot":
+            return Codicon.rocket;
+        case "interactive":
+            return Codicon.comment;
+        }
+    }
+    if (property === SessionConfigKey.AutoApprove) {
+        if (value === "autopilot") {
+            return Codicon.rocket;
+        }
+        if (value === "autoApprove") {
+            return Codicon.warning;
+        }
+        if (value === "assisted") {
+            return Codicon.sparkle;
+        }
+        return Codicon.key;
+    }
+    if (property === ClaudeSessionConfigKey.PermissionMode && typeof value === "string") {
+        switch (value) {
+        case "default":
+            return Codicon.shield;
+        case "acceptEdits":
+            return Codicon.edit;
+        case "plan":
+            return Codicon.lightbulb;
+        case "auto":
+            return Codicon.sparkle;
+        case "bypassPermissions":
+            return Codicon.warning;
+        }
+    }
+    if (property === CodexSessionConfigKey.PermissionsPreset && typeof value === "string") {
+        switch (value) {
+        case "default":
+            return Codicon.shield;
+        case "auto-review":
+            return Codicon.sparkle;
+        case "full-access":
+            return Codicon.warning;
+        }
+    }
+    return undefined;
+}
+function toActionItems(property, items, currentValue, policyRestricted = false, sandboxToggle) {
+    const actionItems = items.map(item => {
+        const disabled = property === SessionConfigKey.AutoApprove && isAutoApproveValuePolicyRestricted(item.value, policyRestricted);
+        const hover = getConfigPickerItemHover(property, item, disabled);
+        return {
+            kind: ActionListItemKind.Action,
+            label: item.label,
+            detail: disabled ? hover : item.description,
+            group: {
+                title: "",
+                icon: getConfigIcon(property, item.value)
+            },
+            disabled,
+            ...(hover ? {
+                hover: {
+                    content: hover
+                }
+            } : {}),
+            item: {
+                ...item,
+                id: item.value,
+                checked: isSelectedValue(currentValue, item.value)
+            }
+        };
+    });
+    if (property === SessionConfigKey.AutoApprove && sandboxToggle) {
+        actionItems.push({
+            kind: ActionListItemKind.Separator,
+            label: ""
+        });
+        actionItems.push({
+            kind: ActionListItemKind.Action,
+            label: sandboxToggle.label,
+            group: {
+                title: "",
+                icon: Codicon.shield
+            },
+            standaloneToggle: sandboxToggle,
+            item: {
+                value: "__sandboxToggle",
+                label: sandboxToggle.label,
+                checked: false
+            }
+        });
+    }
+    return actionItems;
+}
+function getAgentHostSandboxSettingId(sessionType, windows) {
+    if (sessionType !== SessionType.AgentHostCopilot) {
+        return undefined;
+    }
+    return getAgentHostCopilotSandboxSettingId(windows);
+}
+function getConfigPickerTriggerLabel(schema, value) {
+    let label;
+    if (schema.type === "boolean") {
+        label = value === true ? ( localize(7968, "On")) : ( localize(7969, "Off"));
+    } else if (typeof value === "string") {
+        const index = schema.enum?.indexOf(value) ?? -1;
+        label = index >= 0 ? schema.enumLabels?.[index] ?? value : value;
+    } else {
+        label = schema.title;
+    }
+    return label;
+}
+function getConfigPickerAccessibleTriggerLabel(label, sandboxed) {
+    return sandboxed ? ( localize(7970, "{0} (sandboxed)", label)) : label;
+}
+function isSelectedValue(currentValue, itemValue) {
+    if (typeof currentValue === "boolean") {
+        return currentValue === (itemValue === "true");
+    }
+    return itemValue === currentValue;
+}
+function getAutoApproveHover(value, fallback) {
+    switch (value) {
+    case ChatPermissionLevel.Default:
+        return localize(
+            7971,
+            "Copilot asks before running tools unless your configured settings allow the tool."
+        );
+    case ChatPermissionLevel.Assisted:
+        return localize(
+            7972,
+            "An LLM judge evaluates each tool call. Tools it doesn't approve require your approval."
+        );
+    case ChatPermissionLevel.AutoApprove:
+        return localize(7973, "Copilot runs all tools without asking for approval.");
+    case ChatPermissionLevel.Autopilot:
+        return localize(
+            7974,
+            "Copilot runs tools without asking for approval and continues until the task is done."
+        );
+    }
+    return fallback ?? ( localize(
+        7975,
+        "Controls whether the agent asks before running tools in this session."
+    ));
+}
+function getEnumValueDescription(schema, value) {
+    if (typeof value !== "string") {
+        return undefined;
+    }
+    const index = schema.enum?.indexOf(value) ?? -1;
+    return index >= 0 ? schema.enumDescriptions?.[index] : undefined;
+}
+function getConfigPickerTriggerHover(property, schema, value, isReadOnly, sandboxed = false) {
+    if (property === CodexSessionConfigKey.PermissionsPreset) {
+        return getEnumValueDescription(schema, value) ?? schema.description ?? schema.title;
+    }
+    if (property !== SessionConfigKey.AutoApprove) {
+        return schema.description ?? schema.title;
+    }
+    let hover = getAutoApproveHover(value, getEnumValueDescription(schema, value));
+    if (isReadOnly) {
+        hover = ( localize(7976, "{0} Read-only.", hover));
+    }
+    if (sandboxed) {
+        hover = ( localize(7977, "{0} Terminal commands are sandboxed.", hover));
+    }
+    return hover;
+}
+function getConfigPickerItemHover(property, item, disabled) {
+    if (disabled) {
+        return localize(7978, "Disabled by your organization. Contact your administrator.");
+    }
+    if (property === SessionConfigKey.AutoApprove) {
+        return getAutoApproveHover(item.value, item.description);
+    }
+    return undefined;
+}
+function getPermissionsLearnMoreUrl(property) {
+    if (property === CodexSessionConfigKey.PermissionsPreset) {
+        return CODEX_APPROVALS_LEARN_MORE_URL;
+    }
+    if (property === ClaudeSessionConfigKey.PermissionMode || property === SessionConfigKey.AutoApprove) {
+        return PERMISSIONS_LEARN_MORE_URL;
+    }
+    return undefined;
+}
+function getConfigPickerListOptions(property) {
+    switch (property) {
+    case SessionConfigKey.Mode:
+        return {
+            minWidth: 260
+        };
+    case SessionConfigKey.AutoApprove:
+        return {
+            minWidth: 255
+        };
+    case CodexSessionConfigKey.PermissionsPreset:
+        return getCodexApprovalsPickerListOptions();
+    default:
+        return undefined;
+    }
+}
+function renderPickerTrigger(slot, disabled, disposables, onOpen, combined = false) {
+    const trigger = append(
+        slot,
+        disabled ? $("span.action-label") : $(combined ? "div.action-label" : "a.action-label")
+    );
+    if (disabled) {
+        trigger.setAttribute("aria-readonly", "true");
+    } else if (!combined) {
+        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;
+}
+const WELL_KNOWN_PICKER_PROPERTIES = ( new Set([
+    SessionConfigKey.Mode,
+    SessionConfigKey.AutoApprove,
+    SessionConfigKey.Isolation,
+    SessionConfigKey.Branch,
+    SessionConfigKey.Permissions,
+    SessionConfigKey.WorktreeBranchPrefix,
+    SessionConfigKey.WorktreeBranchTrack,
+    SessionConfigKey.WorktreeCreateNewBranch,
+    SessionConfigKey.WorktreeIncludeFiles,
+    SessionConfigKey.ShellInitScripts,
+    SessionConfigKey.SandboxEnabled,
+    ClaudeSessionConfigKey.PermissionMode,
+    CodexSessionConfigKey.PermissionsPreset
+]));
+function isClaimedByDedicatedPicker(property, schema) {
+    if (property === SessionConfigKey.AutoApprove) {
+        return isWellKnownAutoApproveSchema(schema);
+    }
+    return ( WELL_KNOWN_PICKER_PROPERTIES.has(property));
+}
+function resolveConfigChipValue(isUntitled, serverValue, overlayValue, schemaDefault) {
+    const preferred = isUntitled ? (overlayValue ?? serverValue) : (serverValue ?? overlayValue);
+    return preferred ?? schemaDefault;
+}
+let AgentHostChatInputPicker = class AgentHostChatInputPicker extends Disposable {
+    constructor(
+        _widget,
+        _property,
+        _agentHostService,
+        _actionWidgetService,
+        _hoverService,
+        _openerService,
+        _workingDirectoryResolver,
+        _workspaceContextService,
+        _provisional,
+        _configurationService,
+        _newSessionFolderService,
+        _dialogService,
+        _storageService,
+        _agentHostEnablementService,
+        _phoneInputPresenter,
+        _preferencesService,
+        _logService
+    ) {
+        super();
+        this._widget = _widget;
+        this._property = _property;
+        this._agentHostService = _agentHostService;
+        this._actionWidgetService = _actionWidgetService;
+        this._hoverService = _hoverService;
+        this._openerService = _openerService;
+        this._workingDirectoryResolver = _workingDirectoryResolver;
+        this._workspaceContextService = _workspaceContextService;
+        this._provisional = _provisional;
+        this._configurationService = _configurationService;
+        this._newSessionFolderService = _newSessionFolderService;
+        this._dialogService = _dialogService;
+        this._storageService = _storageService;
+        this._agentHostEnablementService = _agentHostEnablementService;
+        this._phoneInputPresenter = _phoneInputPresenter;
+        this._preferencesService = _preferencesService;
+        this._logService = _logService;
+        this._pickerVisible = false;
+        this._initialResolveCts = this._registerInitialResolveCts();
+        this._renderDisposables = this._register(( new DisposableStore()));
+        this._splitTrigger = this._register(( new MutableDisposable()));
+        this._pickerDisposables = this._register(( new DisposableStore()));
+        this._sandboxConfigChanged = observableSignal(this);
+        this._filterDelayer = this._register(( new Delayer(200)));
+        this._subRef = this._register(( new MutableDisposable()));
+        this._register(this._widget.onDidChangeViewModel(() => {
+            this._reattach();
+        }));
+        this._register(this._provisional.onDidChange(sessionResource => {
+            const current = this._widget.viewModel?.sessionResource;
+            if (current && ( current.toString()) === ( sessionResource.toString())) {
+                this._reattach();
+            }
+        }));
+        this._register(this._agentHostService.onAgentHostStart(async () => {
+            const request = this._hostOperatingSystemRequest;
+            await request;
+            if (!this._store.isDisposed && request && this._hostOperatingSystemRequest === request && this._hostOperatingSystem === undefined) {
+                this._hostOperatingSystemRequest = undefined;
+                this._getSandboxSettingId();
+            }
+        }));
+        this._register(this._configurationService.onDidChangeConfiguration(e => {
+            if (e.affectsConfiguration(ChatConfiguration.ExperimentalModePermissionsPicker)) {
+                this._hidePicker();
+                this._renderChip();
+                return;
+            }
+            if (this._isModePickerCombined() && (e.affectsConfiguration(ChatConfiguration.GlobalAutoApprove) || e.affectsConfiguration(ChatConfiguration.AssistedPermissionsEnabled))) {
+                this._hidePicker();
+            }
+            const sandboxSettingId = this._getSandboxSettingId();
+            if (e.affectsConfiguration(ChatConfiguration.PermissionsSandboxToggleEnabled) || e.affectsConfiguration(AgentHostCustomTerminalToolEnabledSettingId) || (sandboxSettingId && e.affectsConfiguration(sandboxSettingId))) {
+                this._refreshTrigger();
+                this._sandboxConfigChanged.trigger(undefined);
+            }
+        }));
+        this._reattach();
+        this._register(autorun(reader => {
+            this._agentHostEnablementService.managedSandboxEnforced.read(reader);
+            this._agentHostEnablementService.managedSandboxAllowsBypass.read(reader);
+            if (this._isModePickerCombined()) {
+                this._hidePicker();
+            }
+            this._refreshTrigger();
+        }));
+        this._register(autorun(reader => {
+            this._phoneInputPresenter.enabled.read(reader);
+            this._hidePicker();
+            this._renderChip();
+        }));
+        this._register(toDisposable(() => this._hidePicker()));
+    }
+    _registerInitialResolveCts() {
+        const cts = ( new MutableDisposable());
+        this._register(toDisposable(() => {
+            this._container = undefined;
+            this._trigger = undefined;
+            this._splitTrigger.clear();
+            this._cancelInitialResolve();
+        }));
+        return this._register(cts);
+    }
+    render(container) {
+        this._container = container;
+        container.classList.add("agent-host-chat-input-picker-host");
+        container.classList.add(`agent-host-chat-input-picker-host-${this._property}`);
+        this._renderChip();
+    }
+    show(anchor) {
+        void this._showPicker(anchor);
+    }
+    _reattach() {
+        this._hidePicker();
+        const sessionResource = this._widget.viewModel?.sessionResource;
+        const provisionalBackend = sessionResource ? this._provisional.get(sessionResource) : undefined;
+        const backendSession = provisionalBackend ?? (sessionResource ? toAgentHostBackendSessionUri(sessionResource) : undefined);
+        if (!sessionResource || !backendSession) {
+            this._subRef.clear();
+            this._initialResolved = undefined;
+            this._cancelInitialResolve();
+            this._renderChip();
+            return;
+        }
+        if (isUntitledChatSession(sessionResource) && !provisionalBackend) {
+            this._subRef.clear();
+            if (!this._initialResolved || ( this._initialResolved.sessionResource.toString()) !== ( sessionResource.toString())) {
+                this._initialResolved = undefined;
+                void this._refreshInitialResolved(sessionResource, backendSession);
+            }
+            void this._provisional.getOrCreate(sessionResource, backendSession.scheme, this._readWorkingDirectory());
+            this._renderChip();
+            return;
+        }
+        this._initialResolved = undefined;
+        this._cancelInitialResolve();
+        const ref = this._agentHostService.getSubscription(StateComponents.Session, backendSession, "AgentHostChatInputPicker");
+        const sub = ref.object;
+        const listener = sub.onDidChange(() => {
+            this._renderChip();
+            this._sandboxConfigChanged.trigger(undefined);
+        });
+        this._subRef.value = {
+            sub,
+            backendSession,
+            dispose: () => {
+                listener.dispose();
+                ref.dispose();
+            }
+        };
+        this._renderChip();
+    }
+    _cancelInitialResolve() {
+        this._initialResolveCts.value?.cancel();
+        this._initialResolveCts.clear();
+    }
+    async _refreshInitialResolved(sessionResource, backendSession) {
+        this._initialResolveCts.value?.cancel();
+        const cts = ( new CancellationTokenSource());
+        this._initialResolveCts.value = cts;
+        try {
+            const result = await this._agentHostService.resolveSessionConfig({
+                provider: backendSession.scheme,
+                workingDirectory: this._readWorkingDirectory()
+            });
+            if (cts.token.isCancellationRequested || this._widget.viewModel?.sessionResource?.toString() !== ( sessionResource.toString())) {
+                return;
+            }
+            this._initialResolved = {
+                sessionResource,
+                result
+            };
+            this._renderChip();
+        } catch {}
+    }
+    _renderChip() {
+        if (!this._container || this._renderDisposables.isDisposed) {
+            return;
+        }
+        const ctx = this._readContext();
+        if (ctx && this._trigger && this._splitTrigger.value && this._container.contains(this._trigger) && this._getModePickerPermissions()) {
+            this._renderTrigger(this._trigger, ctx.schema, ctx.value, false);
+            return;
+        }
+        this._trigger = undefined;
+        this._splitTrigger.clear();
+        this._renderDisposables.clear();
+        clearNode(this._container);
+        this._container.classList.remove("agent-host-chat-input-picker-has-icon");
+        const sessionResource = this._widget.viewModel?.sessionResource;
+        const isStartedSession = !!sessionResource && !isUntitledChatSession(sessionResource);
+        if (!ctx || (isStartedSession && ctx.schema.sessionMutable === false)) {
+            this._container.style.display = "none";
+            this._container.classList.add("agent-host-chat-input-picker-host-hidden");
+            return;
+        }
+        if (this._property === SessionConfigKey.AutoApprove && !isWellKnownAutoApproveSchema(ctx.schema)) {
+            this._container.style.display = "none";
+            this._container.classList.add("agent-host-chat-input-picker-host-hidden");
+            return;
+        }
+        if (this._property === SessionConfigKey.AutoApprove && this._isModePickerCombined()) {
+            this._container.style.display = "none";
+            this._container.classList.add("agent-host-chat-input-picker-host-hidden");
+            return;
+        }
+        this._container.style.display = "";
+        this._container.classList.remove("agent-host-chat-input-picker-host-hidden");
+        const slot = append(this._container, $(".agent-host-chat-input-picker-slot"));
+        this._renderDisposables.add({
+            dispose: () => slot.remove()
+        });
+        const isReadOnly = !!ctx.schema.readOnly || (isStartedSession && ctx.schema.sessionMutable === false);
+        const trigger = renderPickerTrigger(
+            slot,
+            isReadOnly,
+            this._renderDisposables,
+            () => this._showPicker(trigger),
+            !!this._getModePickerPermissions()
+        );
+        this._trigger = trigger;
+        this._renderDisposables.add(this._hoverService.setupDelayedHover(trigger, () => ({
+            content: this._getModePickerPermissions() ? trigger.ariaLabel ?? "" : getConfigPickerTriggerHover(this._property, ctx.schema, ctx.value, isReadOnly, this._isSandboxed())
+        })));
+        this._renderTrigger(trigger, ctx.schema, ctx.value, isReadOnly);
+    }
+    _renderTrigger(trigger, schema, value, isReadOnly) {
+        const previous = this._splitTrigger.value;
+        this._splitTrigger.clear();
+        const icon = getConfigIcon(this._property, value);
+        this._container?.classList.toggle("agent-host-chat-input-picker-has-icon", !!icon);
+        const label = getConfigPickerTriggerLabel(schema, value);
+        const permissions = this._getModePickerPermissions();
+        if (permissions) {
+            trigger.ariaLabel = getModePickerAriaLabel(label, permissions);
+            this._splitTrigger.value = renderModePickerTrigger(trigger, {
+                label,
+                icon,
+                labelClassName: "agent-host-chat-input-picker-label"
+            }, permissions, (anchor, openPermissions) => {
+                void this._showPicker(anchor, openPermissions);
+            }, previous);
+            return;
+        }
+        clearNode(trigger);
+        if (icon) {
+            append(trigger, renderIcon(getCompactCodicon(icon))).ariaHidden = "true";
+        }
+        if (this._property === SessionConfigKey.AutoApprove) {
+            trigger.classList.toggle("warning", value === "autopilot" || value === "assisted");
+            trigger.classList.toggle("info", value === "autoApprove");
+        }
+        const labelSpan = append(trigger, $("span.agent-host-chat-input-picker-label"));
+        labelSpan.textContent = label;
+        const sandboxed = this._isSandboxed();
+        if (sandboxed) {
+            const sandboxIcon = append(trigger, renderIcon(Codicon.shield));
+            sandboxIcon.classList.add("agent-host-chat-input-picker-sandbox-icon");
+            sandboxIcon.ariaHidden = "true";
+        }
+        const accessibleLabel = getConfigPickerAccessibleTriggerLabel(label, sandboxed);
+        trigger.setAttribute("aria-label", isReadOnly ? ( localize(7979, "{0}: {1}, Read-Only", schema.title, accessibleLabel)) : ( localize(7980, "{0}: {1}", schema.title, accessibleLabel)));
+    }
+    _refreshTrigger() {
+        const trigger = this._trigger;
+        const ctx = this._readContext();
+        if (!trigger || !ctx) {
+            return;
+        }
+        const sessionResource = this._widget.viewModel?.sessionResource;
+        const isStartedSession = !!sessionResource && !isUntitledChatSession(sessionResource);
+        const isReadOnly = !!ctx.schema.readOnly || (isStartedSession && ctx.schema.sessionMutable === false);
+        this._renderTrigger(trigger, ctx.schema, ctx.value, isReadOnly);
+    }
+    _isSandboxed() {
+        return this._property === SessionConfigKey.AutoApprove && this._isSandboxToggleSettingEnabled() && this._isSandboxingEnabled();
+    }
+    _isModePickerCombined() {
+        const sessionResource = this._widget.viewModel?.sessionResource;
+        const mode = this._readContext(SessionConfigKey.Mode);
+        const permissions = this._readContext(SessionConfigKey.AutoApprove);
+        const isStartedSession = !!sessionResource && !isUntitledChatSession(sessionResource);
+        return !this._phoneInputPresenter.enabled.get() && !(isStartedSession && (mode?.schema.sessionMutable === false || permissions?.schema.sessionMutable === false)) && shouldCombineModeAndPermissions(
+            this._configurationService.getValue(ChatConfiguration.ExperimentalModePermissionsPicker) === true,
+            !!sessionResource && getChatSessionType(sessionResource) === SessionType.AgentHostCopilot,
+            mode?.schema,
+            permissions?.schema
+        );
+    }
+    _getModePickerPermissions() {
+        if (this._property !== SessionConfigKey.Mode || !this._isModePickerCombined()) {
+            return undefined;
+        }
+        const ctx = this._readContext(SessionConfigKey.AutoApprove);
+        return ctx ? {
+            label: getConfigPickerTriggerLabel(ctx.schema, ctx.value),
+            level: isChatPermissionLevel(ctx.value) ? ctx.value : ChatPermissionLevel.Default,
+            sandboxed: this._isSandboxingEnabled()
+        } : undefined;
+    }
+    _readContext(property = this._property) {
+        const sessionResource = this._widget.viewModel?.sessionResource;
+        if (!sessionResource) {
+            return undefined;
+        }
+        if (this._subRef.value) {
+            const state = this._subRef.value.sub.value;
+            if (!state || state instanceof Error) {
+                return undefined;
+            }
+            const overlay = this._provisional.getResolvedConfig(sessionResource);
+            const schemaSource = overlay?.schema ?? state.config?.schema;
+            const schema = schemaSource?.properties[property];
+            if (!schema) {
+                return undefined;
+            }
+            const serverValue = state.config?.values?.[property];
+            const overlayValue = overlay?.values?.[property];
+            const value = resolveConfigChipValue(
+                isUntitledChatSession(sessionResource),
+                serverValue,
+                overlayValue,
+                schema.default
+            );
+            return {
+                backendSession: this._subRef.value.backendSession,
+                schema,
+                value
+            };
+        }
+        if (this._initialResolved && ( this._initialResolved.sessionResource.toString()) === ( sessionResource.toString())) {
+            const schema = this._initialResolved.result.schema.properties[property];
+            if (!schema) {
+                return undefined;
+            }
+            const backendSession = toAgentHostBackendSessionUri(sessionResource);
+            if (!backendSession) {
+                return undefined;
+            }
+            const value = this._initialResolved.result.values?.[property] ?? schema.default;
+            return {
+                backendSession,
+                schema,
+                value
+            };
+        }
+        return undefined;
+    }
+    async _getActionItems(property, schema, value) {
+        const items = await this._getItems(schema, undefined, property);
+        const policyRestricted = isAutoApprovePolicyRestricted(this._configurationService);
+        const actionItems = toActionItems(
+            property,
+            items,
+            value,
+            policyRestricted,
+            this._getSandboxStandaloneToggle(property)
+        );
+        const permissionsLearnMoreUrl = getPermissionsLearnMoreUrl(property);
+        if (permissionsLearnMoreUrl) {
+            const learnMoreLabel = ( localize(7981, "Learn more about permissions"));
+            actionItems.push({
+                kind: ActionListItemKind.Separator,
+                label: ""
+            });
+            actionItems.push({
+                kind: ActionListItemKind.Action,
+                label: learnMoreLabel,
+                group: {
+                    title: "",
+                    icon: Codicon.blank
+                },
+                item: {
+                    value: LEARN_MORE_VALUE,
+                    label: learnMoreLabel
+                }
+            });
+        }
+        return actionItems;
+    }
+    _hidePicker() {
+        if (this._pickerVisible) {
+            this._actionWidgetService.hide();
+        }
+    }
+    async _showPicker(trigger, openPermissions = false) {
+        if (this._actionWidgetService.isVisible) {
+            return;
+        }
+        const ctx = this._readContext();
+        if (!ctx || ctx.schema.readOnly) {
+            return;
+        }
+        const sessionResource = this._widget.viewModel?.sessionResource;
+        const anchor = trigger === this._trigger ? this._splitTrigger.value?.modeButton ?? trigger : trigger;
+        const modeItems = await this._getActionItems(this._property, ctx.schema, ctx.value);
+        if (modeItems.length === 0) {
+            return;
+        }
+        const permissions = this._getModePickerPermissions();
+        const showFilter = modeItems.length > FILTER_THRESHOLD || ctx.schema.enumDynamic;
+        const actionItems = createModePickerModeItems(modeItems, !!permissions);
+        let initialFocusItemId = modeItems.find(item => item.item?.checked)?.item?.id;
+        const permissionContext = permissions ? this._readContext(SessionConfigKey.AutoApprove) : undefined;
+        if (permissions && permissionContext) {
+            const permissionItems = await this._getActionItems(
+                SessionConfigKey.AutoApprove,
+                permissionContext.schema,
+                permissionContext.value
+            );
+            const permissionActions = permissionItems.map(item => {
+                const value = item.item;
+                return {
+                    ...item,
+                    item: value ? toAction({
+                        id: `agentHostPermissions.${value.value}`,
+                        label: value.label,
+                        checked: value.value === LEARN_MORE_VALUE ? undefined : value.checked,
+                        enabled: !item.disabled,
+                        run: () => this._selectItem(SessionConfigKey.AutoApprove, permissionContext.backendSession, value)
+                    }) : undefined
+                };
+            });
+            if (openPermissions) {
+                initialFocusItemId = permissionActions.find(item => item.item?.checked)?.item?.id;
+            }
+            actionItems.push(
+                ...createModePickerPermissionsItems(permissions, permissionActions, async () => {
+                    this._hidePicker();
+                    await this._preferencesService.openSettings({
+                        jsonEditor: false,
+                        query: AGENT_HOST_PERMISSIONS_SETTINGS_QUERY
+                    });
+                })
+            );
+        }
+        if (this._store.isDisposed || this._actionWidgetService.isVisible || !isEqual(sessionResource, this._widget.viewModel?.sessionResource)) {
+            return;
+        }
+        const combinedTrigger = permissions ? this._trigger : undefined;
+        const delegate = {
+            onSelect: item => hasKey(item, {
+                run: true
+            }) ? item.run() : this._selectItem(this._property, ctx.backendSession, item),
+            onFilter: ctx.schema.enumDynamic ? query => this._filterDelayer.trigger(async () => {
+                const refreshed = this._readContext();
+                if (!refreshed) {
+                    return [];
+                }
+                return toActionItems(
+                    this._property,
+                    await this._getItems(refreshed.schema, query),
+                    refreshed.value,
+                    isAutoApprovePolicyRestricted(this._configurationService),
+                    this._getSandboxStandaloneToggle()
+                );
+            }) : undefined,
+            onHide: () => {
+                this._pickerVisible = false;
+                anchor.ariaExpanded = "false";
+                combinedTrigger?.removeAttribute(MODE_PERMISSIONS_PICKER_OPEN_ATTRIBUTE);
+                this._pickerDisposables.clear();
+                anchor.focus();
+            }
+        };
+        this._pickerVisible = true;
+        anchor.ariaHasPopup = permissions ? "menu" : "listbox";
+        anchor.ariaExpanded = "true";
+        this._actionWidgetService.show(
+            `agentHostChatInputPicker.${this._property}`,
+            false,
+            actionItems,
+            delegate,
+            anchor,
+            undefined,
+            [],
+            {
+                getWidgetAriaLabel: () => ( localize(7982, "{0} Picker", ctx.schema.title)),
+                ...getModePermissionsPickerAccessibilityProvider(!!permissions)
+            },
+            withChatInputPickerMotion({
+                ...getConfigPickerListOptions(this._property),
+                ...(permissions ? getModePermissionsPickerOptions(openPermissions, initialFocusItemId) : {}),
+                ...(showFilter ? {
+                    showFilter: true,
+                    filterPlaceholder: ( localize(7983, "Filter..."))
+                } : {})
+            })
+        );
+        combinedTrigger?.setAttribute(MODE_PERMISSIONS_PICKER_OPEN_ATTRIBUTE, "true");
+        if (permissions) {
+            const allowsBypass = this._agentHostEnablementService.managedSandboxAllowsBypass.get();
+            this._pickerDisposables.add(autorun(reader => {
+                if (allowsBypass !== this._agentHostEnablementService.managedSandboxAllowsBypass.read(reader)) {
+                    this._hidePicker();
+                }
+            }));
+        }
+        if (( actionItems.some(item => item.standaloneToggle))) {
+            let previousToggle = actionItems.find(item => item.standaloneToggle)?.standaloneToggle;
+            this._pickerDisposables.add(autorun(reader => {
+                this._agentHostEnablementService.managedSandboxEnforced.read(reader);
+                this._agentHostEnablementService.managedSandboxAllowsBypass.read(reader);
+                this._sandboxConfigChanged.read(reader);
+                const standaloneToggle = this._getSandboxStandaloneToggle(permissions ? SessionConfigKey.AutoApprove : this._property);
+                if (equalsAgentHostSandboxTogglePresentation(previousToggle, standaloneToggle)) {
+                    return;
+                }
+                previousToggle = standaloneToggle;
+                this._actionWidgetService.updateItems(actionItems.map(item => item.standaloneToggle ? {
+                    ...item,
+                    standaloneToggle
+                } : item));
+            }));
+        }
+    }
+    async _selectItem(property, backendSession, item) {
+        this._actionWidgetService.hide();
+        if (item.value === LEARN_MORE_VALUE) {
+            const url = getPermissionsLearnMoreUrl(property);
+            if (url) {
+                await this._openerService.open(( URI.parse(url)));
+            }
+        } else {
+            await this._confirmAndSetValue(backendSession, item, property);
+        }
+    }
+    _getSandboxSettingId() {
+        const sessionResource = this._widget.viewModel?.sessionResource;
+        const sessionType = sessionResource ? getChatSessionType(sessionResource) : undefined;
+        if (sessionType !== SessionType.AgentHostCopilot || this._store.isDisposed) {
+            return undefined;
+        }
+        this._hostOperatingSystemRequest ??= this._resolveHostOperatingSystem();
+        return getAgentHostSandboxSettingId(sessionType, this._hostOperatingSystem === OperatingSystem.Windows);
+    }
+    async _resolveHostOperatingSystem() {
+        try {
+            const os = await getAgentHostOperatingSystem(this._agentHostService);
+            if (this._store.isDisposed) {
+                return;
+            }
+            this._hostOperatingSystem = os;
+            if (this._getSandboxSettingId() === undefined) {
+                return;
+            }
+            this._hidePicker();
+            this._refreshTrigger();
+            this._sandboxConfigChanged.trigger(undefined);
+        } catch (error) {
+            this._logService.error("Failed to resolve agent host OS for the sandbox picker", error);
+        }
+    }
+    _isSandboxToggleSettingEnabled() {
+        return this._configurationService.getValue(ChatConfiguration.PermissionsSandboxToggleEnabled) === true;
+    }
+    _isSandboxingEnabled() {
+        return getAgentHostSandboxToggleState(this._readSandboxToggleState())?.checked ?? false;
+    }
+    _readSandboxToggleState() {
+        const context = this._readContext(SessionConfigKey.SandboxEnabled);
+        const value = context?.value;
+        const settingId = this._getSandboxSettingId();
+        return {
+            provider: context?.backendSession.scheme,
+            sessionEnabled: value === AgentSandboxEnabledValue.On ? true : value === AgentSandboxEnabledValue.Off ? false : undefined,
+            globalEnabled: settingId !== undefined && isAgentSandboxEnabledValue(this._configurationService.getValue(settingId)),
+            managedEnabled: this._agentHostEnablementService.managedSandboxEnforced.get(),
+            allowsBypass: this._agentHostEnablementService.managedSandboxAllowsBypass.get()
+        };
+    }
+    _getSandboxStandaloneToggle(property = this._property) {
+        const settingId = this._getSandboxSettingId();
+        const context = this._readContext(SessionConfigKey.SandboxEnabled);
+        const sessionResource = this._widget.viewModel?.sessionResource;
+        if (property !== SessionConfigKey.AutoApprove || !this._isSandboxToggleSettingEnabled() || !settingId || !context || !sessionResource) {
+            return undefined;
+        }
+        const workingDirectory = this._readWorkingDirectory();
+        return createAgentHostSandboxToggle(() => this._readSandboxToggleState(), checked => {
+            const target = checked ? AgentSandboxEnabledValue.On : AgentSandboxEnabledValue.Off;
+            void this._setValue(
+                context.backendSession,
+                target,
+                SessionConfigKey.SandboxEnabled,
+                sessionResource,
+                workingDirectory
+            ).catch(onUnexpectedError);
+        });
+    }
+    async _getItems(schema, query, property = this._property) {
+        if (schema.type === "boolean") {
+            return [{
+                value: "true",
+                label: ( localize(7984, "On"))
+            }, {
+                value: "false",
+                label: ( localize(7985, "Off"))
+            }];
+        }
+        const sessionResource = this._widget.viewModel?.sessionResource;
+        const backendSession = this._subRef.value?.backendSession ?? (sessionResource ? toAgentHostBackendSessionUri(sessionResource) : undefined);
+        if (schema.enumDynamic && backendSession) {
+            try {
+                const result = await this._agentHostService.sessionConfigCompletions({
+                    provider: backendSession.scheme,
+                    property,
+                    query,
+                    workingDirectory: this._readWorkingDirectory(),
+                    config: this._readCurrentValues()
+                });
+                return this._filterAutoApproveItems(result.items.map(item => this._fromCompletion(item)), property);
+            } catch {}
+        }
+        return this._filterAutoApproveItems((schema.enum ?? []).map((value, index) => ({
+            value: String(value),
+            label: schema.enumLabels?.[index] ?? String(value),
+            description: schema.enumDescriptions?.[index]
+        })), property);
+    }
+    _filterAutoApproveItems(items, property = this._property) {
+        if (property !== SessionConfigKey.AutoApprove) {
+            return items;
+        }
+        const assistedPermissionsEnabled = isAssistedPermissionsEnabled(this._configurationService);
+        return items.filter(item => isPermissionLevelVisible(item.value, assistedPermissionsEnabled));
+    }
+    _fromCompletion(item) {
+        return {
+            value: item.value,
+            label: item.label,
+            description: item.description
+        };
+    }
+    _readWorkingDirectory() {
+        const state = this._subRef.value?.sub.value;
+        if (state && !(state instanceof Error)) {
+            const cwd = state.workingDirectories?.[0];
+            return typeof cwd === "string" ? ( URI.parse(cwd)) : cwd;
+        }
+        const sessionResource = this._widget.viewModel?.sessionResource;
+        return (sessionResource && this._newSessionFolderService.getFolder(sessionResource)) ?? (sessionResource && this._workingDirectoryResolver.resolve(sessionResource)) ?? this._newSessionFolderService.getDefaultFolder() ?? this._workspaceContextService.getWorkspace().folders[0]?.uri;
+    }
+    _readCurrentValues() {
+        const sessionResource = this._widget.viewModel?.sessionResource;
+        const overlay = sessionResource ? this._provisional.getResolvedConfig(sessionResource) : undefined;
+        const state = this._subRef.value?.sub.value;
+        if (state && !(state instanceof Error)) {
+            return {
+                ...(state.config?.values ?? {}),
+                ...(overlay?.values ?? {})
+            };
+        }
+        return overlay?.values ?? this._initialResolved?.result.values;
+    }
+    async _confirmAndSetValue(backendSession, item, property = this._property) {
+        const sessionResource = this._widget.viewModel?.sessionResource;
+        const value = item.value;
+        if (property === SessionConfigKey.AutoApprove && !isPermissionLevelVisible(value, isAssistedPermissionsEnabled(this._configurationService))) {
+            return;
+        }
+        if (property === SessionConfigKey.AutoApprove) {
+            const levelToConfirm = isChatPermissionLevel(value) ? value : (value !== ChatPermissionLevel.Default ? ChatPermissionLevel.AutoApprove : undefined);
+            if (levelToConfirm) {
+                const confirmed = await maybeConfirmElevatedPermissionLevel(levelToConfirm, this._dialogService, this._storageService, {
+                    defaultSettingKey: ChatConfiguration.DefaultConfiguration,
+                    levelLabel: item.label
+                });
+                if (!confirmed) {
+                    return;
+                }
+            }
+        }
+        if (isEqual(sessionResource, this._widget.viewModel?.sessionResource)) {
+            await this._setValue(backendSession, value, property);
+        }
+    }
+    async _setValue(
+        backendSession,
+        value,
+        property = this._property,
+        sessionResource = this._widget.viewModel?.sessionResource,
+        workingDirectory = this._readWorkingDirectory()
+    ) {
+        if (!sessionResource) {
+            return;
+        }
+        const isCurrentSession = isEqual(sessionResource, this._widget.viewModel?.sessionResource);
+        const ctx = isCurrentSession ? this._readContext(property) : undefined;
+        const normalizedValue = ctx?.schema.type === "boolean" ? value === "true" : normalizeSessionConfigValue(property, value, isAutoApprovePolicyRestricted(this._configurationService));
+        const partial = {
+            [property]: normalizedValue
+        };
+        const nextConfig = {
+            ...(isCurrentSession ? this._readCurrentValues() : undefined),
+            ...partial
+        };
+        if (isUntitledChatSession(sessionResource)) {
+            const provider = backendSession.scheme;
+            const created = await this._provisional.applyConfigChange(sessionResource, provider, workingDirectory, partial);
+            if (!created) {
+                return;
+            }
+            if (isEqual(sessionResource, this._widget.viewModel?.sessionResource) && (!this._subRef.value || ( this._subRef.value.backendSession.toString()) !== ( created.toString()))) {
+                this._reattach();
+            }
+            return;
+        }
+        this._agentHostService.dispatch(( backendSession.toString()), {
+            type: ActionType.SessionConfigChanged,
+            config: partial
+        });
+        if (isCurrentSession) {
+            await this._provisional.refreshResolvedConfig(sessionResource, backendSession.scheme, workingDirectory, nextConfig);
+        }
+    }
+};
+AgentHostChatInputPicker = ( __decorate([( __param(2, IAgentHostService)), ( __param(3, IActionWidgetService)), ( __param(4, IHoverService)), ( __param(5, IOpenerService)), ( __param(6, IAgentHostSessionWorkingDirectoryResolver)), ( __param(7, IWorkspaceContextService)), ( __param(8, IAgentHostUntitledProvisionalSessionService)), ( __param(9, IConfigurationService)), ( __param(10, IAgentHostNewSessionFolderService)), ( __param(11, IDialogService)), ( __param(12, IStorageService)), ( __param(13, IAgentHostEnablementService)), ( __param(14, IChatPhoneInputPresenter)), ( __param(15, IPreferencesService)), ( __param(16, ILogService))], AgentHostChatInputPicker));
+class AgentHostChatInputPickerActionViewItem extends BaseActionViewItem {
+    constructor(action, _picker) {
+        super(undefined, action);
+        this._picker = _picker;
+        this._register(this._picker);
+    }
+    render(container) {
+        this._picker.render(container);
+    }
+}
+
+export { AgentHostChatInputPicker, AgentHostChatInputPickerActionViewItem, WELL_KNOWN_PICKER_PROPERTIES, getAgentHostSandboxSettingId, getConfigPickerAccessibleTriggerLabel, getConfigPickerItemHover, getConfigPickerListOptions, getConfigPickerTriggerHover, getConfigPickerTriggerLabel, isClaimedByDedicatedPicker, isWellKnownAutoApproveSchema, resolveConfigChipValue };