@codingame/monaco-vscode-workbench-service-override 37.3.3 → 37.3.5

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

@@ -0,0 +1,464 @@
+
+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 { renderIcon } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/iconLabel/iconLabels';
+import { EventType as EventType$1, Gesture } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/touch';
+import { Disposable, DisposableStore, MutableDisposable, DisposableMap, toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { hasKey } from '@codingame/monaco-vscode-api/vscode/vs/base/common/types';
+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 { IHoverService } from '@codingame/monaco-vscode-api/vscode/vs/platform/hover/browser/hover.service';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { SessionConfigKey } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/sessionConfigKeys';
+import { ITelemetryService } from '@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service';
+import { isAgentHostProvider } from '@codingame/monaco-vscode-api/vscode/vs/sessions/common/agentHostSessionsProvider';
+import { ISessionsProvidersService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsProvidersService.service';
+import { reportNewChatPickerClosed } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/chat/browser/newChatPickerTelemetry';
+import { didExplicitlyEnableChatPetAutopilot, ChatPetAchievementIds } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chatPetAchievements';
+import { IChatPetService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chatPetService.service';
+import { getAgentHostModeIcon } from './agentHostModeIcon.js';
+import { AgentHostPermissionPickerDelegate } from './agentHostPermissionPickerDelegate.js';
+import { PermissionPicker } from '@codingame/monaco-vscode-katex-common/vscode/vs/sessions/contrib/providers/copilotChatSessions/browser/permissionPicker';
+import { MODE_PERMISSIONS_PICKER_OPEN_ATTRIBUTE, renderModePickerTrigger, getModePermissionsPickerOptions, createModePickerPermissionsItems, AGENT_HOST_PERMISSIONS_SETTINGS_QUERY, createModePickerModeItems, getModePermissionsPickerAccessibilityProvider, isWellKnownModeSchema, getModePickerAriaLabel } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentHost/agentHostModePickerPresentation';
+import { ChatConfiguration } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
+import { IPreferencesService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/preferences/common/preferences.service';
+import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
+
+let AgentHostSessionEnumPicker = class AgentHostSessionEnumPicker extends Disposable {
+    constructor(
+        _session,
+        _actionWidgetService,
+        _sessionsProvidersService,
+        _telemetryService,
+        _hoverService
+    ) {
+        super();
+        this._session = _session;
+        this._actionWidgetService = _actionWidgetService;
+        this._sessionsProvidersService = _sessionsProvidersService;
+        this._telemetryService = _telemetryService;
+        this._hoverService = _hoverService;
+        this._renderDisposables = this._register(( new DisposableStore()));
+        this._triggerGesture = this._register(( new MutableDisposable()));
+        this._providerListeners = this._register(( new DisposableMap()));
+        this._pickerListener = this._register(( new MutableDisposable()));
+        this._pickerVisible = false;
+        this._register(autorun(reader => {
+            this._session.read(reader);
+            this._updateTrigger();
+        }));
+        this._register(this._sessionsProvidersService.onDidChangeProviders(e => {
+            for (const provider of e.removed) {
+                this._providerListeners.deleteAndDispose(provider.id);
+            }
+            this._watchProviders(e.added);
+            this._updateTrigger();
+        }));
+        this._watchProviders(this._sessionsProvidersService.getProviders());
+        this._register(toDisposable(() => this._hidePicker()));
+    }
+    render(container) {
+        this._renderDisposables.clear();
+        this._triggerGesture.clear();
+        this._containerElement = container;
+        const slot = append(container, $(".sessions-chat-picker-slot"));
+        this._renderDisposables.add({
+            dispose: () => slot.remove()
+        });
+        this._slotElement = slot;
+        const trigger = this._createTrigger(slot);
+        trigger.tabIndex = 0;
+        trigger.role = "button";
+        trigger.ariaHasPopup = "listbox";
+        trigger.ariaExpanded = "false";
+        this._triggerElement = trigger;
+        this._renderDisposables.add(this._hoverService.setupDelayedHover(trigger, () => ({
+            content: this._getTriggerTooltip(this._getActiveContext()?.tooltip ?? "")
+        })));
+        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();
+            }
+        }));
+        this._updateTrigger();
+        return trigger;
+    }
+    focus() {
+        this._triggerElement?.focus();
+    }
+    _watchProviders(providers) {
+        for (const provider of providers) {
+            if (!isAgentHostProvider(provider) || ( this._providerListeners.has(provider.id))) {
+                continue;
+            }
+            this._providerListeners.set(
+                provider.id,
+                provider.onDidChangeSessionConfig(() => this._updateTrigger())
+            );
+        }
+    }
+    _createTrigger(slot) {
+        return append(slot, $("a.action-label"));
+    }
+    _getTriggerTooltip(tooltip) {
+        return tooltip;
+    }
+    _getFooterActionItems() {
+        return [];
+    }
+    _watchActionItems(_items) {
+        return Disposable.None;
+    }
+    _handleFooterActionItem(_item) {
+        return false;
+    }
+    _onDidSelectValue(_previousValue, _selectedValue) {}
+    _getActionItems(items, currentValue) {
+        return items.map(item => ({
+            kind: ActionListItemKind.Action,
+            label: item.label,
+            detail: item.description,
+            group: {
+                title: "",
+                icon: this._getActionItemIcon(item, currentValue)
+            },
+            item: {
+                ...item,
+                id: item.value,
+                checked: item.value === currentValue
+            }
+        }));
+    }
+    _getAccessibilityProvider() {
+        return {
+            getWidgetAriaLabel: () => this._getWidgetAriaLabel()
+        };
+    }
+    _getListOptions() {
+        return undefined;
+    }
+    _isCurrentlyResolvingConfig() {
+        const session = this._session.get();
+        if (!session) {
+            return false;
+        }
+        const provider = this._sessionsProvidersService.getProvider(session.providerId);
+        if (!provider || !isAgentHostProvider(provider)) {
+            return false;
+        }
+        return provider.isSessionConfigResolving(session.sessionId).get();
+    }
+    showPicker(anchor, onHide) {
+        return this._showPicker(anchor, onHide);
+    }
+    _getActiveContext() {
+        const session = this._session.get();
+        if (!session) {
+            return undefined;
+        }
+        const rawProvider = this._sessionsProvidersService.getProvider(session.providerId);
+        if (!rawProvider || !isAgentHostProvider(rawProvider)) {
+            return undefined;
+        }
+        const config = rawProvider.getSessionConfig(session.sessionId);
+        const schema = config?.schema.properties[this._property];
+        if (!schema || !this._isWellKnownSchema(schema)) {
+            return undefined;
+        }
+        const enumValues = (schema.enum ?? []).map(value => String(value));
+        const enumLabels = schema.enumLabels ?? [];
+        const enumDescriptions = schema.enumDescriptions ?? [];
+        const items = enumValues.map((value, index) => ({
+            value,
+            label: enumLabels[index] ?? value,
+            description: enumDescriptions[index]
+        }));
+        const rawCurrent = config?.values[this._property] ?? schema.default;
+        const currentValue = typeof rawCurrent === "string" && enumValues.includes(rawCurrent) ? rawCurrent : enumValues[0] ?? "";
+        return {
+            provider: rawProvider,
+            sessionId: session.sessionId,
+            currentValue,
+            items,
+            tooltip: schema.description ?? schema.title ?? ""
+        };
+    }
+    _updateTrigger() {
+        if (!this._triggerElement || !this._slotElement || !this._containerElement) {
+            return;
+        }
+        const ctx = this._getActiveContext();
+        if (!ctx) {
+            this._slotElement.style.display = "none";
+            this._containerElement.style.display = "none";
+            return;
+        }
+        this._slotElement.style.display = "";
+        this._containerElement.style.display = "";
+        const item = ctx.items.find(i => i.value === ctx.currentValue);
+        const label = item?.label ?? ctx.currentValue;
+        const icon = this._getTriggerIcon(ctx.currentValue);
+        const isResolving = ctx.provider.isSessionConfigResolving(ctx.sessionId).get();
+        this._slotElement.classList.toggle("resolving", isResolving);
+        this._triggerElement.setAttribute("aria-disabled", isResolving ? "true" : "false");
+        this._renderTriggerLabel(this._triggerElement, label, icon);
+        this._triggerElement.ariaLabel = this._getTriggerAriaLabel(label);
+        if (this._triggerElement.role === "group") {
+            this._triggerGesture.clear();
+        } else if (!this._triggerGesture.value) {
+            this._triggerGesture.value = Gesture.addTarget(this._triggerElement);
+        }
+    }
+    _renderTriggerLabel(trigger, label, icon) {
+        clearNode(trigger);
+        if (icon) {
+            append(trigger, renderIcon(icon)).ariaHidden = "true";
+        }
+        append(trigger, $("span.sessions-chat-dropdown-label", undefined, label));
+    }
+    _hidePicker() {
+        if (this._pickerVisible) {
+            this._actionWidgetService.hide();
+        }
+    }
+    _showPicker(
+        anchor = this._triggerElement,
+        onHide,
+        listOptions = this._getListOptions()
+    ) {
+        if (!anchor || this._actionWidgetService.isVisible) {
+            return false;
+        }
+        const ctx = this._getActiveContext();
+        if (!ctx) {
+            return false;
+        }
+        if (this._isCurrentlyResolvingConfig()) {
+            return false;
+        }
+        const actionItems = this._getActionItems(ctx.items, ctx.currentValue);
+        actionItems.push(...this._getFooterActionItems());
+        const ariaTarget = this._triggerElement?.contains(anchor) ? anchor : this._triggerElement;
+        const combinedTrigger = this._triggerElement?.classList.contains("agent-host-mode-permissions-trigger") ? this._triggerElement : undefined;
+        const delegate = {
+            onSelect: async item => {
+                if (hasKey(item, {
+                    run: true
+                })) {
+                    await item.run();
+                    return;
+                }
+                this._actionWidgetService.hide();
+                if (this._handleFooterActionItem(item)) {
+                    return;
+                }
+                if (!( ctx.items.some(candidate => candidate.value === item.value))) {
+                    return;
+                }
+                const previousItem = ctx.items.find(i => i.value === ctx.currentValue);
+                reportNewChatPickerClosed(this._telemetryService, {
+                    id: this._telemetryId,
+                    optionIdBefore: ctx.currentValue,
+                    optionIdAfter: item.value,
+                    optionLabelBefore: previousItem?.label ?? ctx.currentValue,
+                    optionLabelAfter: item.label,
+                    isPII: false
+                });
+                ctx.provider.setSessionConfigValue(ctx.sessionId, this._property, item.value).then(() => this._onDidSelectValue(ctx.currentValue, item.value)).catch(() => {});
+            },
+            onHide: () => {
+                this._pickerVisible = false;
+                this._pickerListener.clear();
+                ariaTarget?.setAttribute("aria-expanded", "false");
+                combinedTrigger?.removeAttribute(MODE_PERMISSIONS_PICKER_OPEN_ATTRIBUTE);
+                anchor.focus();
+                onHide?.();
+            }
+        };
+        this._pickerVisible = true;
+        ariaTarget?.setAttribute("aria-expanded", "true");
+        this._actionWidgetService.show(
+            this._pickerId,
+            false,
+            actionItems,
+            delegate,
+            anchor,
+            undefined,
+            [],
+            this._getAccessibilityProvider(),
+            listOptions
+        );
+        combinedTrigger?.setAttribute(MODE_PERMISSIONS_PICKER_OPEN_ATTRIBUTE, "true");
+        this._pickerListener.value = this._watchActionItems(actionItems);
+        return true;
+    }
+};
+AgentHostSessionEnumPicker = ( __decorate([( __param(1, IActionWidgetService)), ( __param(2, ISessionsProvidersService)), ( __param(3, ITelemetryService)), ( __param(4, IHoverService))], AgentHostSessionEnumPicker));
+let AgentHostModePicker = class AgentHostModePicker extends AgentHostSessionEnumPicker {
+    constructor(
+        session,
+        actionWidgetService,
+        sessionsProvidersService,
+        telemetryService,
+        hoverService,
+        _chatPetService,
+        instantiationService,
+        _configurationService,
+        _preferencesService
+    ) {
+        super(
+            session,
+            actionWidgetService,
+            sessionsProvidersService,
+            telemetryService,
+            hoverService
+        );
+        this._chatPetService = _chatPetService;
+        this._configurationService = _configurationService;
+        this._preferencesService = _preferencesService;
+        this._splitTrigger = this._register(( new MutableDisposable()));
+        this._property = SessionConfigKey.Mode;
+        this._pickerId = "agentHostModePicker";
+        this._telemetryId = "NewChatAgentHostModePicker";
+        this._permissionDelegate = this._register(
+            instantiationService.createInstance(AgentHostPermissionPickerDelegate, session)
+        );
+        this._permissionPicker = this._register(
+            instantiationService.createInstance(PermissionPicker, this._permissionDelegate)
+        );
+        this._register(autorun(reader => {
+            session.read(reader);
+            this._permissionDelegate.isModePickerCombined.read(reader);
+            this._permissionDelegate.currentPermissionLevel.read(reader);
+            this._permissionDelegate.isResolving.read(reader);
+            this._permissionDelegate.sandboxToggleSettingId.read(reader);
+            this._permissionDelegate.managedSandboxEnforced.read(reader);
+            this._permissionDelegate.managedSandboxAllowsBypass.read(reader);
+            this._hidePicker();
+            this._updateTrigger();
+        }));
+        this._register(autorun(reader => {
+            this._permissionDelegate.sandboxEnabled.read(reader);
+            this._updateTrigger();
+        }));
+        this._register(this._configurationService.onDidChangeConfiguration(e => {
+            if (e.affectsConfiguration(ChatConfiguration.GlobalAutoApprove) || e.affectsConfiguration(ChatConfiguration.AssistedPermissionsEnabled)) {
+                this._hidePicker();
+            }
+            if (e.affectsConfiguration(ChatConfiguration.PermissionsSandboxToggleEnabled) || ( this._permissionDelegate.sandboxToggleConfigurationKeys.some(key => e.affectsConfiguration(key)))) {
+                this._updateTrigger();
+            }
+        }));
+    }
+    _renderTriggerLabel(trigger, label, icon) {
+        const previous = this._splitTrigger.value;
+        this._splitTrigger.clear();
+        if (this._permissionDelegate.isModePickerCombined.get()) {
+            this._splitTrigger.value = renderModePickerTrigger(trigger, {
+                label,
+                icon,
+                labelClassName: "sessions-chat-dropdown-label"
+            }, this._permissionPicker.presentation, (anchor, openPermissions) => {
+                const initialFocusItemId = openPermissions ? `permissionPicker.${this._permissionDelegate.currentPermissionLevel.get()}` : this._getActiveContext()?.currentValue;
+                this._showPicker(
+                    anchor,
+                    undefined,
+                    getModePermissionsPickerOptions(openPermissions, initialFocusItemId)
+                );
+            }, previous);
+        } else {
+            trigger.classList.remove("agent-host-mode-permissions-trigger");
+            trigger.role = "button";
+            trigger.tabIndex = 0;
+            trigger.ariaHasPopup = "listbox";
+            super._renderTriggerLabel(trigger, label, icon);
+        }
+    }
+    _createTrigger(slot) {
+        return append(slot, $("div.action-label"));
+    }
+    focus() {
+        (this._splitTrigger.value?.modeButton ?? this._triggerElement)?.focus();
+    }
+    _showPicker(
+        anchor = this._triggerElement,
+        onHide,
+        listOptions = this._getListOptions()
+    ) {
+        return super._showPicker(
+            anchor === this._triggerElement ? this._splitTrigger.value?.modeButton ?? anchor : anchor,
+            onHide,
+            listOptions
+        );
+    }
+    _getTriggerTooltip(tooltip) {
+        return this._permissionDelegate.isModePickerCombined.get() ? this._triggerElement?.ariaLabel ?? tooltip : tooltip;
+    }
+    _getFooterActionItems() {
+        const session = this._session.get();
+        return this._permissionDelegate.isModePickerCombined.get() ? [...createModePickerPermissionsItems(
+            this._permissionPicker.presentation,
+            this._permissionPicker.getActionListItems(() => this._session.get() === session),
+            async () => {
+                this._hidePicker();
+                await this._preferencesService.openSettings({
+                    jsonEditor: false,
+                    query: AGENT_HOST_PERMISSIONS_SETTINGS_QUERY
+                });
+            }
+        )] : [];
+    }
+    _getActionItems(items, currentValue) {
+        return createModePickerModeItems(
+            super._getActionItems(items, currentValue),
+            this._permissionDelegate.isModePickerCombined.get()
+        );
+    }
+    _watchActionItems(items) {
+        return this._permissionPicker.watchSandboxToggle(items);
+    }
+    _getAccessibilityProvider() {
+        return {
+            ...super._getAccessibilityProvider(),
+            ...getModePermissionsPickerAccessibilityProvider(this._permissionDelegate.isModePickerCombined.get())
+        };
+    }
+    _onDidSelectValue(previousValue, selectedValue) {
+        if (didExplicitlyEnableChatPetAutopilot(previousValue, selectedValue)) {
+            this._chatPetService.unlockAchievement(ChatPetAchievementIds.AutopilotEnabled);
+        }
+    }
+    _getListOptions() {
+        return this._permissionDelegate.isModePickerCombined.get() ? getModePermissionsPickerOptions(false, this._getActiveContext()?.currentValue) : {
+            minWidth: 260
+        };
+    }
+    _isWellKnownSchema(schema) {
+        return isWellKnownModeSchema(schema);
+    }
+    _getTriggerIcon(value) {
+        return getAgentHostModeIcon(value);
+    }
+    _getActionItemIcon(item) {
+        return getAgentHostModeIcon(item.value);
+    }
+    _getTriggerAriaLabel(label) {
+        return this._permissionDelegate.isModePickerCombined.get() ? getModePickerAriaLabel(label, this._permissionPicker.presentation) : ( localize(4196, "Pick Agent Mode, {0}", label));
+    }
+    _getWidgetAriaLabel() {
+        return this._permissionDelegate.isModePickerCombined.get() ? ( localize(4197, "Mode and Permissions Picker")) : ( localize(4198, "Agent Mode Picker"));
+    }
+};
+AgentHostModePicker = ( __decorate([( __param(1, IActionWidgetService)), ( __param(2, ISessionsProvidersService)), ( __param(3, ITelemetryService)), ( __param(4, IHoverService)), ( __param(5, IChatPetService)), ( __param(6, IInstantiationService)), ( __param(7, IConfigurationService)), ( __param(8, IPreferencesService))], AgentHostModePicker));
+
+export { AgentHostModePicker, AgentHostSessionEnumPicker };

package/vscode/src/vs/sessions/contrib/providers/agentHost/browser/agentHostPermissionPickerActionItem.d.ts

@@ -0,0 +1,35 @@
+import { IObservable, ISettableObservable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/observable";
+import { MenuItemAction } from "@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions";
+import { IActionWidgetService } from "@codingame/monaco-vscode-api/vscode/vs/platform/actionWidget/browser/actionWidget.service";
+import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+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 { IHoverService } from "@codingame/monaco-vscode-api/vscode/vs/platform/hover/browser/hover.service";
+import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { IKeybindingService } from "@codingame/monaco-vscode-api/vscode/vs/platform/keybinding/common/keybinding.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 { IChatInputPickerOptions } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/widget/input/chatInputPickerActionItem";
+import { IChatInputPickerResponsiveState } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/widget/input/chatInputPickerResponsiveLayout";
+import { PermissionPickerActionItem } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/widget/input/permissionPickerActionItem";
+import { IActiveSession } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/sessionsManagement";
+/**
+ * Agent host wrapper around the workbench {@link PermissionPickerActionItem}
+ * for use in the running chat widget's secondary toolbar
+ * (`MenuId.ChatInputSecondary`). Owns its
+ * {@link AgentHostPermissionPickerDelegate} and reactively hides itself when
+ * the active session's `autoApprove` schema doesn't match the well-known
+ * shape.
+ */
+export declare class AgentHostPermissionPickerActionItem extends PermissionPickerActionItem implements IChatInputPickerResponsiveState {
+    private readonly _delegate;
+    private readonly _compact;
+    constructor(action: MenuItemAction, pickerOptions: IChatInputPickerOptions & {
+        readonly compact: ISettableObservable<boolean>;
+    }, session: IObservable<IActiveSession | undefined>, instantiationService: IInstantiationService, actionWidgetService: IActionWidgetService, keybindingService: IKeybindingService, contextKeyService: IContextKeyService, telemetryService: ITelemetryService, configurationService: IConfigurationService, dialogService: IDialogService, openerService: IOpenerService, storageService: IStorageService, hoverService: IHoverService);
+    isCompact(): boolean;
+    setCompact(compact: boolean): void;
+    render(container: HTMLElement): void;
+    protected updateEnabled(): void;
+}

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

@@ -0,0 +1,90 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { IActionWidgetService } from '@codingame/monaco-vscode-api/vscode/vs/platform/actionWidget/browser/actionWidget.service';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+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 { IHoverService } from '@codingame/monaco-vscode-api/vscode/vs/platform/hover/browser/hover.service';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { IKeybindingService } from '@codingame/monaco-vscode-api/vscode/vs/platform/keybinding/common/keybinding.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 { PermissionPickerActionItem } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/widget/input/permissionPickerActionItem';
+import { AgentHostPermissionPickerDelegate } from './agentHostPermissionPickerDelegate.js';
+import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
+
+let AgentHostPermissionPickerActionItem = class AgentHostPermissionPickerActionItem extends PermissionPickerActionItem {
+    constructor(
+        action,
+        pickerOptions,
+        session,
+        instantiationService,
+        actionWidgetService,
+        keybindingService,
+        contextKeyService,
+        telemetryService,
+        configurationService,
+        dialogService,
+        openerService,
+        storageService,
+        hoverService
+    ) {
+        const delegate = instantiationService.createInstance(AgentHostPermissionPickerDelegate, session);
+        super(
+            action,
+            delegate,
+            pickerOptions,
+            actionWidgetService,
+            keybindingService,
+            contextKeyService,
+            telemetryService,
+            configurationService,
+            dialogService,
+            openerService,
+            storageService,
+            hoverService
+        );
+        this._delegate = this._register(delegate);
+        this._compact = pickerOptions.compact;
+        this._register(autorun(reader => {
+            delegate.currentPermissionLevel.read(reader);
+            this.refresh();
+        }));
+    }
+    isCompact() {
+        return this._compact.get();
+    }
+    setCompact(compact) {
+        this._compact.set(compact, undefined);
+    }
+    render(container) {
+        super.render(container);
+        this._register(autorun(reader => {
+            const visible = this._delegate.isApplicable.read(reader);
+            container.style.display = visible ? "" : "none";
+        }));
+        this._register(autorun(reader => {
+            const isResolving = this._delegate.isResolving.read(reader);
+            const element = this.element;
+            if (!element) {
+                return;
+            }
+            element.classList.toggle("sessions-chat-config-resolving", isResolving);
+            this.setDropdownEnabled(!isResolving);
+            if (isResolving) {
+                element.setAttribute("aria-disabled", "true");
+            } else {
+                element.removeAttribute("aria-disabled");
+            }
+        }));
+    }
+    updateEnabled() {
+        super.updateEnabled();
+        this.setDropdownEnabled(!this._delegate.isResolving.get());
+    }
+};
+AgentHostPermissionPickerActionItem = ( __decorate([( __param(3, IInstantiationService)), ( __param(4, IActionWidgetService)), ( __param(5, IKeybindingService)), ( __param(6, IContextKeyService)), ( __param(7, ITelemetryService)), ( __param(8, IConfigurationService)), ( __param(9, IDialogService)), ( __param(10, IOpenerService)), ( __param(11, IStorageService)), ( __param(12, IHoverService))], AgentHostPermissionPickerActionItem));
+
+export { AgentHostPermissionPickerActionItem };