@codingame/monaco-vscode-chat-service-override 37.2.0 → 37.3.1

package/vscode/src/vs/sessions/contrib/providers/copilotChatSessions/browser/permissionPicker.d.ts

@@ -0,0 +1,135 @@
+import { IAction } from "@codingame/monaco-vscode-api/vscode/vs/base/common/actions";
+import { Disposable, DisposableStore, IDisposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IObservable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/observable";
+import { ThemeIcon } from "@codingame/monaco-vscode-api/vscode/vs/base/common/themables";
+import { IActionListItem } 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 { IAgentHostEnablementService } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostEnablementService.service";
+import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+import { IDialogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/dialogs/common/dialogs.service";
+import { IHoverService } from "@codingame/monaco-vscode-api/vscode/vs/platform/hover/browser/hover.service";
+import { IOpenerService } from "@codingame/monaco-vscode-api/vscode/vs/platform/opener/common/opener.service";
+import { IStorageService } from "@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service";
+import { ITelemetryService } from "@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service";
+import { IChatSessionsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService.service";
+import { ChatPermissionLevel } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants";
+import { IModePickerPermissions } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentHost/agentHostModePickerPresentation";
+import { ISessionsProvidersService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsProvidersService.service";
+import { IActiveSession } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/sessionsManagement";
+/**
+ * Strategy for the per-provider parts of {@link PermissionPicker}: how to read
+ * back the current level (if at all), whether the picker should be visible
+ * given the active session, and where to write the user's selection.
+ *
+ * Implementations live with the provider they back (e.g.
+ * {@link CopilotPermissionPickerDelegate} below for the default Copilot
+ * provider, or `AgentHostPermissionPickerDelegate` in the agent-host folder).
+ */
+export interface IPermissionPickerDelegate {
+    /**
+     * If provided, the picker's trigger label reactively tracks this. If
+     * omitted, the picker manages its own internal state and starts at
+     * {@link ChatPermissionLevel.Default}.
+     */
+    readonly currentPermissionLevel?: IObservable<ChatPermissionLevel | undefined>;
+    /**
+     * If provided, the picker hides itself when this is `false`. Used by
+     * delegates whose applicability depends on the active session.
+     */
+    readonly isApplicable?: IObservable<boolean>;
+    /** Whether the picker is temporarily unavailable while its backing config resolves. */
+    readonly isResolving?: IObservable<boolean>;
+    /**
+     * The ordered set of permission levels the picker should offer. When
+     * omitted, the picker offers the default Copilot set
+     * (`Default` / `Bypass` / `Autopilot`). Agent-host sessions override this
+     * to offer `Default` / `Bypass`.
+     */
+    readonly availableLevels?: readonly ChatPermissionLevel[];
+    /**
+     * The setting id the elevated-level warning dialog links to as "make this
+     * the default". Defaults to `chat.permissions.default`; agent-host sessions
+     * pass `chat.defaultConfiguration`.
+     */
+    readonly defaultSettingKey?: string;
+    getPermissionLevelMeta(level: ChatPermissionLevel, meta: IPermissionLevelMeta): IPermissionLevelMeta;
+    /**
+     * Called after the user selects a level (and any required confirmation
+     * dialog has been accepted).
+     */
+    setPermissionLevel(level: ChatPermissionLevel): void | Promise<void>;
+    /**
+     * Optional hover content for delegates that need provider-specific copy.
+     */
+    getPermissionLevelHover?(level: ChatPermissionLevel, meta: IPermissionLevelMeta): string | undefined;
+    readonly isSandboxToggleApplicable?: () => boolean;
+    readonly getSandboxToggleSettingId?: () => string | undefined;
+    /** Tracks asynchronous setting ID changes, including agent host switches. */
+    readonly sandboxToggleSettingId?: IObservable<string | undefined>;
+    readonly getSandboxToggleProvider?: () => string | undefined;
+    readonly sandboxEnabled?: IObservable<boolean | undefined>;
+    setSandboxEnabled?(enabled: boolean): void;
+    readonly managedSandboxEnforced?: IObservable<boolean>;
+    readonly sandboxToggleConfigurationKeys?: readonly string[];
+}
+export interface IPermissionLevelMeta {
+    readonly label: string;
+    readonly detail: string;
+    readonly icon: ThemeIcon;
+    readonly hover?: string;
+}
+/** Default level set offered when a delegate does not specify {@link IPermissionPickerDelegate.availableLevels}. */
+export declare const DEFAULT_PERMISSION_LEVELS: readonly ChatPermissionLevel[];
+export declare function getPermissionLevelMeta(level: ChatPermissionLevel): IPermissionLevelMeta;
+export declare class PermissionPicker extends Disposable {
+    protected readonly _delegate: IPermissionPickerDelegate;
+    protected readonly actionWidgetService: IActionWidgetService;
+    protected readonly configurationService: IConfigurationService;
+    protected readonly dialogService: IDialogService;
+    protected readonly openerService: IOpenerService;
+    protected readonly storageService: IStorageService;
+    protected readonly telemetryService: ITelemetryService;
+    protected readonly hoverService: IHoverService;
+    private readonly agentHostEnablementService;
+    protected _currentLevel: ChatPermissionLevel;
+    protected _triggerElement: HTMLElement | undefined;
+    protected readonly _renderDisposables: DisposableStore;
+    private readonly _pickerDisposables;
+    private readonly _sandboxDefaultChanged;
+    constructor(_delegate: IPermissionPickerDelegate, actionWidgetService: IActionWidgetService, configurationService: IConfigurationService, dialogService: IDialogService, openerService: IOpenerService, storageService: IStorageService, telemetryService: ITelemetryService, hoverService: IHoverService, agentHostEnablementService: IAgentHostEnablementService);
+    render(container: HTMLElement): HTMLElement;
+    showPicker(): void;
+    get presentation(): IModePickerPermissions;
+    getActionListItems(isCurrentContext: () => boolean): readonly IActionListItem<IAction>[];
+    private _getActionItems;
+    private _selectItem;
+    protected _showPicker(): void;
+    watchSandboxToggle<T>(items: readonly IActionListItem<T>[]): IDisposable;
+    protected _isResolving(): boolean;
+    protected _selectLevel(level: ChatPermissionLevel, isCurrentContext?: () => boolean): Promise<void>;
+    private _updateTriggerLabel;
+    private _getSandboxStandaloneToggle;
+    private _isSandboxToggleAvailable;
+    private _isSandboxingEnabled;
+    private _readSandboxToggleState;
+    private _affectsSandboxToggle;
+    private _getPermissionLevelHover;
+    private _getTriggerHover;
+    protected _getPermissionLevelMeta(level: ChatPermissionLevel): IPermissionLevelMeta;
+}
+/**
+ * Default-Copilot {@link IPermissionPickerDelegate}: writes the user's chosen
+ * level back to the active {@link CopilotChatSessionsProvider} session, and
+ * exposes that session's `permissionLevel` observable so the picker's
+ * trigger label tracks the session's current level rather than resetting to
+ * the configured default on every re-render.
+ */
+export declare class CopilotPermissionPickerDelegate extends Disposable implements IPermissionPickerDelegate {
+    private readonly _session;
+    private readonly _sessionsProvidersService;
+    private readonly _chatSessionsService;
+    readonly currentPermissionLevel: IObservable<ChatPermissionLevel | undefined>;
+    getPermissionLevelMeta(_level: ChatPermissionLevel, meta: IPermissionLevelMeta): IPermissionLevelMeta;
+    constructor(_session: IObservable<IActiveSession | undefined>, _sessionsProvidersService: ISessionsProvidersService, _chatSessionsService: IChatSessionsService);
+    setPermissionLevel(level: ChatPermissionLevel): void;
+}

package/vscode/src/vs/sessions/contrib/providers/copilotChatSessions/browser/permissionPicker.js

@@ -0,0 +1,521 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { append, $, EventType, addDisposableListener, EventHelper, clearNode } 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 { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
+import { toAction } from '@codingame/monaco-vscode-api/vscode/vs/base/common/actions';
+import { Disposable, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+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 { equalsAgentHostSandboxTogglePresentation, createAgentHostSandboxToggle, getAgentHostSandboxToggleState } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/browser/agentHostSandboxToggle';
+import { IAgentHostEnablementService } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostEnablementService.service';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { IDialogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/dialogs/common/dialogs.service';
+import { IHoverService } from '@codingame/monaco-vscode-api/vscode/vs/platform/hover/browser/hover.service';
+import { IOpenerService } from '@codingame/monaco-vscode-api/vscode/vs/platform/opener/common/opener.service';
+import { IStorageService } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service';
+import { ITelemetryService } from '@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service';
+import { isAgentSandboxEnabledValue } from '@codingame/monaco-vscode-api/vscode/vs/platform/sandbox/common/settings';
+import { maybeConfirmElevatedPermissionLevel } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatPermissionWarnings';
+import { IChatSessionsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService.service';
+import { ChatPermissionLevel, ChatConfiguration, isChatPermissionLevel } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
+import { reportNewChatPickerClosed } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/chat/browser/newChatPickerTelemetry';
+import { ISessionsProvidersService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsProvidersService.service';
+import { CopilotChatSessionsProvider } from './copilotChatSessionsProvider.js';
+import { derived } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/derived';
+import { observableSignal } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableSignal';
+import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
+
+const PERMISSION_LEVEL_OPTION_ID = "permissionLevel";
+const DEFAULT_PERMISSION_LEVELS = [
+    ChatPermissionLevel.Default,
+    ChatPermissionLevel.AutoApprove,
+    ChatPermissionLevel.Autopilot
+];
+function getPermissionLevelMeta(level) {
+    switch (level) {
+    case ChatPermissionLevel.Assisted:
+        return {
+            label: ( localize(4236, "Assisted permissions")),
+            detail: ( localize(4237, "Evaluates risk before running tools")),
+            icon: Codicon.sparkle,
+            hover: ( localize(
+                4238,
+                "An LLM judge evaluates each tool call. Tools it doesn't approve require your approval."
+            ))
+        };
+    case ChatPermissionLevel.AutoApprove:
+        return {
+            label: ( localize(4239, "Allow all")),
+            detail: ( localize(4240, "Runs tool calls without asking")),
+            icon: Codicon.warning
+        };
+    case ChatPermissionLevel.Autopilot:
+        return {
+            label: ( localize(4241, "Autopilot (Preview)")),
+            detail: ( localize(4242, "Works autonomously within permissions")),
+            icon: Codicon.rocket,
+            hover: ( localize(
+                4243,
+                "Auto-approve all tool calls and continue until the task is done. Autopilot may increase costs."
+            ))
+        };
+    case ChatPermissionLevel.Default:
+    default:
+        return {
+            label: ( localize(4244, "Default permissions")),
+            detail: ( localize(4245, "Asks when approval settings don't apply")),
+            icon: Codicon.shield
+        };
+    }
+}
+let PermissionPicker = class PermissionPicker extends Disposable {
+    constructor(
+        _delegate,
+        actionWidgetService,
+        configurationService,
+        dialogService,
+        openerService,
+        storageService,
+        telemetryService,
+        hoverService,
+        agentHostEnablementService
+    ) {
+        super();
+        this._delegate = _delegate;
+        this.actionWidgetService = actionWidgetService;
+        this.configurationService = configurationService;
+        this.dialogService = dialogService;
+        this.openerService = openerService;
+        this.storageService = storageService;
+        this.telemetryService = telemetryService;
+        this.hoverService = hoverService;
+        this.agentHostEnablementService = agentHostEnablementService;
+        this._currentLevel = ChatPermissionLevel.Default;
+        this._renderDisposables = this._register(( new DisposableStore()));
+        this._pickerDisposables = this._register(( new DisposableStore()));
+        this._sandboxDefaultChanged = observableSignal(this);
+    }
+    render(container) {
+        this._renderDisposables.clear();
+        const policyRestricted = this.configurationService.inspect(ChatConfiguration.GlobalAutoApprove).policyValue === false;
+        const configuredDefault = this.configurationService.getValue(ChatConfiguration.DefaultPermissionLevel);
+        const initialLevel = isChatPermissionLevel(configuredDefault) ? configuredDefault : ChatPermissionLevel.Default;
+        this._currentLevel = policyRestricted ? ChatPermissionLevel.Default : initialLevel;
+        const slot = append(
+            container,
+            $(".sessions-chat-picker-slot.sessions-chat-permission-picker")
+        );
+        this._renderDisposables.add({
+            dispose: () => slot.remove()
+        });
+        const trigger = append(slot, $("a.action-label"));
+        trigger.tabIndex = 0;
+        trigger.role = "button";
+        this._triggerElement = trigger;
+        this._updateTriggerLabel(trigger);
+        if (this._delegate.getPermissionLevelHover) {
+            this._renderDisposables.add(this.hoverService.setupDelayedHover(trigger, () => {
+                const meta = this._getPermissionLevelMeta(this._currentLevel);
+                return {
+                    content: this._getTriggerHover(this._currentLevel, meta)
+                };
+            }));
+        }
+        this._renderDisposables.add(Gesture.addTarget(trigger));
+        for (const eventType of [EventType.CLICK, EventType$1.Tap]) {
+            this._renderDisposables.add(addDisposableListener(trigger, eventType, e => {
+                EventHelper.stop(e, true);
+                this._showPicker();
+            }));
+        }
+        this._renderDisposables.add(addDisposableListener(trigger, EventType.KEY_DOWN, e => {
+            if (e.key === "Enter" || e.key === " ") {
+                EventHelper.stop(e, true);
+                this._showPicker();
+            }
+        }));
+        const currentPermissionLevel = this._delegate.currentPermissionLevel;
+        if (currentPermissionLevel) {
+            this._renderDisposables.add(autorun(reader => {
+                const level = currentPermissionLevel.read(reader);
+                if (level === undefined) {
+                    return;
+                }
+                this._currentLevel = level;
+                this._updateTriggerLabel(trigger);
+            }));
+        }
+        const isApplicable = this._delegate.isApplicable;
+        if (isApplicable) {
+            this._renderDisposables.add(autorun(reader => {
+                const visible = isApplicable.read(reader);
+                slot.style.display = visible ? "" : "none";
+                container.style.display = visible ? "" : "none";
+            }));
+        }
+        const isResolving = this._delegate.isResolving;
+        if (isResolving) {
+            this._renderDisposables.add(autorun(reader => {
+                const resolving = isResolving.read(reader);
+                slot.classList.toggle("resolving", resolving);
+                trigger.setAttribute("aria-disabled", resolving ? "true" : "false");
+            }));
+        }
+        this._renderDisposables.add(autorun(reader => {
+            this._delegate.isResolving?.read(reader);
+            this._delegate.isApplicable?.read(reader);
+            this._delegate.managedSandboxEnforced?.read(reader);
+            this._delegate.sandboxEnabled?.read(reader);
+            this._delegate.sandboxToggleSettingId?.read(reader);
+            this.agentHostEnablementService.managedSandboxAllowsBypass.read(reader);
+            this._updateTriggerLabel(trigger);
+        }));
+        this._renderDisposables.add(this.configurationService.onDidChangeConfiguration(e => {
+            if (this._affectsSandboxToggle(e)) {
+                this._updateTriggerLabel(trigger);
+            }
+        }));
+        return slot;
+    }
+    showPicker() {
+        this._showPicker();
+    }
+    get presentation() {
+        const level = this._delegate.currentPermissionLevel?.get() ?? this._currentLevel;
+        return {
+            label: this._getPermissionLevelMeta(level).label,
+            level,
+            sandboxed: this._delegate.isSandboxToggleApplicable?.() === true && this._isSandboxingEnabled()
+        };
+    }
+    getActionListItems(isCurrentContext) {
+        this._currentLevel = this._delegate.currentPermissionLevel?.get() ?? this._currentLevel;
+        return this._getActionItems().map(item => {
+            const permission = item.item;
+            return {
+                ...item,
+                item: permission ? toAction({
+                    id: `permissionPicker.${permission.level ?? permission.kind}`,
+                    label: permission.label,
+                    checked: permission.level ? permission.checked : undefined,
+                    enabled: !item.disabled,
+                    run: () => this._selectItem(permission, isCurrentContext)
+                }) : undefined
+            };
+        });
+    }
+    _getActionItems() {
+        const policyRestricted = this.configurationService.inspect(ChatConfiguration.GlobalAutoApprove).policyValue === false;
+        const levels = this._delegate.availableLevels ?? DEFAULT_PERMISSION_LEVELS;
+        const items = levels.map(level => {
+            const meta = this._getPermissionLevelMeta(level);
+            const disabled = level !== ChatPermissionLevel.Default && policyRestricted;
+            const hover = this._delegate.getPermissionLevelHover ? (disabled ? ( localize(4246, "Disabled by enterprise policy")) : this._getPermissionLevelHover(level, meta)) : meta.hover;
+            return {
+                kind: ActionListItemKind.Action,
+                group: {
+                    kind: ActionListItemKind.Header,
+                    title: "",
+                    icon: meta.icon
+                },
+                item: {
+                    level,
+                    label: meta.label,
+                    icon: meta.icon,
+                    checked: this._currentLevel === level
+                },
+                label: meta.label,
+                detail: meta.detail,
+                ...(hover ? {
+                    hover: {
+                        content: hover
+                    }
+                } : {}),
+                disabled
+            };
+        });
+        const sandboxToggle = this._getSandboxStandaloneToggle();
+        if (sandboxToggle) {
+            const disabled = sandboxToggle.disabled === true;
+            items.push({
+                kind: ActionListItemKind.Separator,
+                label: "",
+                disabled: false
+            });
+            items.push({
+                kind: ActionListItemKind.Action,
+                group: {
+                    kind: ActionListItemKind.Header,
+                    title: "",
+                    icon: Codicon.shield
+                },
+                item: {
+                    kind: "sandbox",
+                    label: sandboxToggle.label,
+                    icon: Codicon.shield,
+                    checked: false
+                },
+                label: sandboxToggle.label,
+                standaloneToggle: sandboxToggle,
+                ...(disabled ? {
+                    hover: {
+                        content: ( localize(4246, "Disabled by enterprise policy"))
+                    }
+                } : {}),
+                disabled
+            });
+        }
+        items.push({
+            kind: ActionListItemKind.Separator,
+            label: "",
+            disabled: false
+        });
+        items.push({
+            kind: ActionListItemKind.Action,
+            group: {
+                kind: ActionListItemKind.Header,
+                title: "",
+                icon: Codicon.blank
+            },
+            item: {
+                kind: "learnMore",
+                label: ( localize(4247, "Learn more about permissions")),
+                icon: Codicon.blank,
+                checked: false
+            },
+            label: ( localize(4247, "Learn more about permissions")),
+            hideIcon: false,
+            disabled: false
+        });
+        return items;
+    }
+    async _selectItem(item, isCurrentContext) {
+        this.actionWidgetService.hide();
+        if (item.level) {
+            const policyRestricted = this.configurationService.inspect(ChatConfiguration.GlobalAutoApprove).policyValue === false;
+            if (!this._isResolving() && !(policyRestricted && item.level !== ChatPermissionLevel.Default)) {
+                await this._selectLevel(item.level, isCurrentContext);
+            }
+        } else if (item.kind === "learnMore") {
+            await this.openerService.open(( URI.parse("https://aka.ms/vscode/docs/permissions")));
+        }
+    }
+    _showPicker() {
+        if (!this._triggerElement || this.actionWidgetService.isVisible || this._isResolving()) {
+            return;
+        }
+        const items = this._getActionItems();
+        const triggerElement = this._triggerElement;
+        const delegate = {
+            onSelect: item => this._selectItem(item),
+            onHide: () => {
+                this._pickerDisposables.clear();
+                triggerElement.focus();
+            }
+        };
+        const listOptions = {
+            minWidth: 255
+        };
+        this.actionWidgetService.show(
+            "permissionPicker",
+            false,
+            items,
+            delegate,
+            this._triggerElement,
+            undefined,
+            [],
+            {
+                getWidgetAriaLabel: () => ( localize(4248, "Permission Picker"))
+            },
+            listOptions
+        );
+        this._pickerDisposables.add(this.watchSandboxToggle(items));
+    }
+    watchSandboxToggle(items) {
+        const sandboxToggle = items.find(item => item.standaloneToggle)?.standaloneToggle;
+        const settingId = this._delegate.getSandboxToggleSettingId?.();
+        let previousToggle = sandboxToggle;
+        if (!sandboxToggle && !this._delegate.sandboxToggleSettingId) {
+            return Disposable.None;
+        }
+        const disposables = ( new DisposableStore());
+        disposables.add(this.configurationService.onDidChangeConfiguration(e => {
+            if (this._affectsSandboxToggle(e)) {
+                this._sandboxDefaultChanged.trigger(undefined);
+            }
+        }));
+        disposables.add(autorun(reader => {
+            this._delegate.sandboxToggleSettingId?.read(reader);
+            if (this._delegate.getSandboxToggleSettingId?.() !== settingId) {
+                this.actionWidgetService.hide();
+                return;
+            }
+            this._delegate.managedSandboxEnforced?.read(reader);
+            this._delegate.sandboxEnabled?.read(reader);
+            this._sandboxDefaultChanged.read(reader);
+            this.agentHostEnablementService.managedSandboxAllowsBypass.read(reader);
+            const standaloneToggle = this._getSandboxStandaloneToggle();
+            if (equalsAgentHostSandboxTogglePresentation(previousToggle, standaloneToggle)) {
+                return;
+            }
+            previousToggle = standaloneToggle;
+            const disabled = standaloneToggle?.disabled === true;
+            this.actionWidgetService.updateItems(items.map(item => item.standaloneToggle ? {
+                ...item,
+                standaloneToggle,
+                disabled,
+                hover: disabled ? {
+                    content: ( localize(4246, "Disabled by enterprise policy"))
+                } : undefined
+            } : item));
+        }));
+        return disposables;
+    }
+    _isResolving() {
+        return this._delegate.isResolving?.get() ?? false;
+    }
+    async _selectLevel(level, isCurrentContext) {
+        const confirmed = await maybeConfirmElevatedPermissionLevel(level, this.dialogService, this.storageService, {
+            defaultSettingKey: this._delegate.defaultSettingKey,
+            levelLabel: this._getPermissionLevelMeta(level).label
+        });
+        if (!confirmed || isCurrentContext?.() === false) {
+            reportNewChatPickerClosed(this.telemetryService, {
+                id: "NewChatPermissionPicker",
+                name: "NewChatPermissionPicker",
+                optionIdBefore: this._currentLevel,
+                optionIdAfter: this._currentLevel,
+                optionLabelBefore: undefined,
+                optionLabelAfter: undefined,
+                isPII: false
+            });
+            return;
+        }
+        reportNewChatPickerClosed(this.telemetryService, {
+            id: "NewChatPermissionPicker",
+            name: "NewChatPermissionPicker",
+            optionIdBefore: this._currentLevel,
+            optionIdAfter: level,
+            optionLabelBefore: undefined,
+            optionLabelAfter: undefined,
+            isPII: false
+        });
+        this._currentLevel = level;
+        this._updateTriggerLabel(this._triggerElement);
+        await this._delegate.setPermissionLevel(level);
+    }
+    _updateTriggerLabel(trigger) {
+        if (!trigger) {
+            return;
+        }
+        clearNode(trigger);
+        const meta = this._getPermissionLevelMeta(this._currentLevel);
+        const sandboxed = this._isSandboxToggleAvailable() && this._isSandboxingEnabled();
+        const accessibleLabel = sandboxed ? ( localize(4249, "{0} (sandboxed)", meta.label)) : meta.label;
+        append(trigger, renderIcon(meta.icon));
+        const labelSpan = append(trigger, $("span.sessions-chat-dropdown-label"));
+        labelSpan.textContent = meta.label;
+        if (sandboxed) {
+            const sandboxIcon = append(trigger, renderIcon(Codicon.shield));
+            sandboxIcon.classList.add("sessions-chat-sandbox-icon");
+            sandboxIcon.ariaHidden = "true";
+        }
+        const hover = this._getPermissionLevelHover(this._currentLevel, meta);
+        trigger.ariaLabel = hover ? ( localize(4250, "Pick Permission Level, {0}, {1}", accessibleLabel, hover)) : ( localize(4251, "Pick Permission Level, {0}", accessibleLabel));
+        trigger.classList.toggle(
+            "warning",
+            this._currentLevel === ChatPermissionLevel.Autopilot || this._currentLevel === ChatPermissionLevel.Assisted
+        );
+        trigger.classList.toggle("info", this._currentLevel === ChatPermissionLevel.AutoApprove);
+    }
+    _getSandboxStandaloneToggle() {
+        if (!this._isSandboxToggleAvailable()) {
+            return undefined;
+        }
+        return createAgentHostSandboxToggle(
+            () => this._readSandboxToggleState(),
+            checked => this._delegate.setSandboxEnabled?.(checked)
+        );
+    }
+    _isSandboxToggleAvailable() {
+        return this.configurationService.getValue(ChatConfiguration.PermissionsSandboxToggleEnabled) === true && this._delegate.isSandboxToggleApplicable?.() === true && this._delegate.setSandboxEnabled !== undefined && this._delegate.getSandboxToggleSettingId?.() !== undefined;
+    }
+    _isSandboxingEnabled() {
+        return getAgentHostSandboxToggleState(this._readSandboxToggleState())?.checked ?? false;
+    }
+    _readSandboxToggleState() {
+        const settingId = this._delegate.getSandboxToggleSettingId?.();
+        return {
+            provider: this._delegate.getSandboxToggleProvider?.(),
+            sessionEnabled: this._delegate.sandboxEnabled?.get(),
+            globalEnabled: settingId !== undefined && isAgentSandboxEnabledValue(this.configurationService.getValue(settingId)),
+            managedEnabled: this._delegate.managedSandboxEnforced?.get() === true,
+            allowsBypass: this.agentHostEnablementService.managedSandboxAllowsBypass.get()
+        };
+    }
+    _affectsSandboxToggle(event) {
+        const settingId = this._delegate.getSandboxToggleSettingId?.();
+        return event.affectsConfiguration(ChatConfiguration.PermissionsSandboxToggleEnabled) || (settingId !== undefined && event.affectsConfiguration(settingId)) || this._delegate.sandboxToggleConfigurationKeys?.some(key => event.affectsConfiguration(key)) === true;
+    }
+    _getPermissionLevelHover(level, meta) {
+        return this._delegate.getPermissionLevelHover?.(level, meta) ?? meta.hover;
+    }
+    _getTriggerHover(level, meta) {
+        const hover = this._getPermissionLevelHover(level, meta) ?? "";
+        return this._isSandboxToggleAvailable() && this._isSandboxingEnabled() ? ( localize(4252, "{0} Terminal commands are sandboxed.", hover)) : hover;
+    }
+    _getPermissionLevelMeta(level) {
+        const meta = getPermissionLevelMeta(level);
+        return this._delegate.getPermissionLevelMeta(level, meta);
+    }
+};
+PermissionPicker = ( __decorate([( __param(1, IActionWidgetService)), ( __param(2, IConfigurationService)), ( __param(3, IDialogService)), ( __param(4, IOpenerService)), ( __param(5, IStorageService)), ( __param(6, ITelemetryService)), ( __param(7, IHoverService)), ( __param(8, IAgentHostEnablementService))], PermissionPicker));
+let CopilotPermissionPickerDelegate = class CopilotPermissionPickerDelegate extends Disposable {
+    getPermissionLevelMeta(_level, meta) {
+        return meta;
+    }
+    constructor(_session, _sessionsProvidersService, _chatSessionsService) {
+        super();
+        this._session = _session;
+        this._sessionsProvidersService = _sessionsProvidersService;
+        this._chatSessionsService = _chatSessionsService;
+        this.currentPermissionLevel = derived(this, reader => {
+            const session = this._session.read(reader);
+            if (!session) {
+                return undefined;
+            }
+            const provider = this._sessionsProvidersService.getProvider(session.providerId);
+            if (!(provider instanceof CopilotChatSessionsProvider)) {
+                return undefined;
+            }
+            return provider.getSession(session.sessionId)?.permissionLevel.read(reader);
+        });
+    }
+    setPermissionLevel(level) {
+        const session = this._session.get();
+        if (!session) {
+            return;
+        }
+        const provider = this._sessionsProvidersService.getProvider(session.providerId);
+        if (provider instanceof CopilotChatSessionsProvider) {
+            const chatSession = provider.getSession(session.sessionId);
+            if (!chatSession) {
+                return;
+            }
+            if (chatSession.setOption) {
+                chatSession.setPermissionLevel(level);
+                chatSession.setOption(PERMISSION_LEVEL_OPTION_ID, level);
+            } else {
+                this._chatSessionsService.setSessionOption(chatSession.resource, PERMISSION_LEVEL_OPTION_ID, level);
+            }
+        }
+    }
+};
+CopilotPermissionPickerDelegate = ( __decorate([( __param(1, ISessionsProvidersService)), ( __param(2, IChatSessionsService))], CopilotPermissionPickerDelegate));
+
+export { CopilotPermissionPickerDelegate, DEFAULT_PERMISSION_LEVELS, PermissionPicker, getPermissionLevelMeta };