@codingame/monaco-vscode-katex-common 26.2.2 → 28.0.0

package/vscode/src/vs/workbench/contrib/chat/browser/widget/input/modePickerActionItem.js

@@ -23,14 +23,28 @@ import { ChatMode } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contr
 import { IChatModeService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatModes.service';
 import { isOrganizationPromptFile } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/utils/promptsServiceUtils';
 import { ChatConfiguration, ChatModeKind, ChatAgentLocation } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
-import { Target, PromptsStorage } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/service/promptsService';
+import { PromptsStorage } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/service/promptsService';
+import { Target } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/promptTypes';
 import { getOpenChatActionIdForMode } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/actions/chatActions';
 import { ToggleAgentModeActionId } from '../../actions/chatExecuteActions.js';
 import { ChatInputPickerActionViewItem } from './chatInputPickerActionItem.js';
 import { IOpenerService } from '@codingame/monaco-vscode-api/vscode/vs/platform/opener/common/opener.service';
+import { IWorkbenchAssignmentService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/assignment/common/assignmentService.service';
+import { observableValue } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableValue';
 import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
 
-const builtinDefaultIcon = Codicon.tasklist;
+const builtinDefaultIcon = mode => {
+    switch (mode.name.get().toLowerCase()) {
+    case "ask":
+        return Codicon.ask;
+    case "edit":
+        return Codicon.edit;
+    case "plan":
+        return Codicon.tasklist;
+    default:
+        return undefined;
+    }
+};
 let ModePickerActionItem = class ModePickerActionItem extends ChatInputPickerActionViewItem {
     constructor(
         action,
@@ -46,19 +60,23 @@ let ModePickerActionItem = class ModePickerActionItem extends ChatInputPickerAct
         commandService,
         _productService,
         telemetryService,
-        openerService
+        openerService,
+        assignmentService
     ) {
+        const assignments = observableValue("modePickerAssignments", {
+            showOldAskMode: false
+        });
         const customAgentTarget = delegate.customAgentTarget?.() ?? Target.Undefined;
         const builtInCategory = {
-            label: ( localize(6201, "Built-In")),
+            label: ( localize(6839, "Built-In")),
             order: 0
         };
         const customCategory = {
-            label: ( localize(6202, "Custom")),
+            label: ( localize(6840, "Custom")),
             order: 1
         };
         const policyDisabledCategory = {
-            label: ( localize(6203, "Managed by your organization")),
+            label: ( localize(6841, "Managed by your organization")),
             order: 999,
             showHeader: true
         };
@@ -73,11 +91,11 @@ let ModePickerActionItem = class ModePickerActionItem extends ChatInputPickerAct
                     if (mode.source?.storage === PromptsStorage.extension) {
                         icon = Codicon.eye;
                         id = `viewAgent:${mode.id}`;
-                        label = ( localize(6204, "View {0} agent", mode.label.get()));
+                        label = ( localize(6842, "View {0} agent", mode.label.get()));
                     } else {
                         icon = Codicon.edit;
                         id = `editAgent:${mode.id}`;
-                        label = ( localize(6205, "Edit {0} agent", mode.label.get()));
+                        label = ( localize(6843, "Edit {0} agent", mode.label.get()));
                     }
                     const modeResource = mode.uri;
                     toolbarActions.push({
@@ -90,27 +108,6 @@ let ModePickerActionItem = class ModePickerActionItem extends ChatInputPickerAct
                             openerService.open(modeResource.get());
                         }
                     });
-                } else if (customAgentTarget === Target.Undefined) {
-                    const label = ( localize(6206, "Configure tools for {0} agent", mode.label.get()));
-                    toolbarActions.push({
-                        id: `configureTools:${mode.id}`,
-                        label,
-                        tooltip: label,
-                        class: ThemeIcon.asClassName(Codicon.tools),
-                        enabled: true,
-                        run: async () => {
-                            actionWidgetService.hide();
-                            if (currentMode.id !== mode.id) {
-                                await commandService.executeCommand(ToggleAgentModeActionId, {
-                                    modeId: mode.id,
-                                    sessionResource: this.delegate.sessionResource()
-                                });
-                            }
-                            await commandService.executeCommand("workbench.action.chat.configureTools", pickerOptions.actionContext, {
-                                source: "modePicker"
-                            });
-                        }
-                    });
                 }
             }
             return {
@@ -151,31 +148,35 @@ let ModePickerActionItem = class ModePickerActionItem extends ChatInputPickerAct
                     content: mode.description.get() ?? chatAgentService.getDefaultAgent(ChatAgentLocation.Chat, mode.kind)?.description ?? action.tooltip,
                     position: this.pickerOptions.hoverPosition
                 },
-                icon: mode.icon.get() ?? (isModeConsideredBuiltIn(mode, this._productService) ? builtinDefaultIcon : undefined),
+                icon: mode.icon.get() ?? (isModeConsideredBuiltIn(mode, this._productService) ? builtinDefaultIcon(mode) : undefined),
                 category: agentModeDisabledViaPolicy ? policyDisabledCategory : customCategory
             };
         };
-        const isUserDefinedCustomAgent = mode => {
-            if (mode.isBuiltin || !mode.source) {
-                return false;
-            }
-            return mode.source.storage === PromptsStorage.local || mode.source.storage === PromptsStorage.user;
-        };
         const actionProviderWithCustomAgentTarget = {
             getActions: () => {
                 const modes = chatModeService.getModes();
                 const currentMode = delegate.currentMode.get();
                 const filteredCustomModes = modes.custom.filter(mode => {
                     const target = mode.target.get();
-                    return isUserDefinedCustomAgent(mode) && (target === customAgentTarget);
+                    return target === customAgentTarget || target === Target.Undefined;
                 });
+                const customModes = groupBy(
+                    filteredCustomModes,
+                    mode => isModeConsideredBuiltIn(mode, this._productService) ? "builtin" : "custom"
+                );
                 const checked = currentMode.id === ChatMode.Agent.id;
                 const defaultAction = {
                     ...makeAction(ChatMode.Agent, ChatMode.Agent),
                     checked
                 };
-                const customActions = ( filteredCustomModes.map(mode => makeActionFromCustomMode(mode, currentMode)));
-                return [defaultAction, ...customActions];
+                defaultAction.category = builtInCategory;
+                const builtInActions = customModes.builtin?.map(mode => {
+                    const action = makeActionFromCustomMode(mode, currentMode);
+                    action.category = builtInCategory;
+                    return action;
+                }) ?? [];
+                const customActions = customModes.custom?.map(mode => makeActionFromCustomMode(mode, currentMode)) ?? [];
+                return [defaultAction, ...builtInActions, ...customActions];
             }
         };
         const actionProvider = {
@@ -183,12 +184,17 @@ let ModePickerActionItem = class ModePickerActionItem extends ChatInputPickerAct
                 const modes = chatModeService.getModes();
                 const currentMode = delegate.currentMode.get();
                 const agentMode = modes.builtin.find(mode => mode.id === ChatMode.Agent.id);
-                const shouldHideEditMode = configurationService.getValue(ChatConfiguration.EditModeHidden) && chatAgentService.hasToolsAgent && currentMode.id !== ChatMode.Edit.id;
-                const otherBuiltinModes = modes.builtin.filter(
-                    mode => mode.id !== ChatMode.Agent.id && !(shouldHideEditMode && mode.id === ChatMode.Edit.id)
-                );
+                const otherBuiltinModes = modes.builtin.filter(mode => {
+                    return mode.id !== ChatMode.Agent.id && shouldShowBuiltInMode(mode, assignments.get(), agentModeDisabledViaPolicy);
+                });
+                const filteredCustomModes = modes.custom.filter(mode => {
+                    if (isModeConsideredBuiltIn(mode, this._productService)) {
+                        return shouldShowBuiltInMode(mode, assignments.get(), agentModeDisabledViaPolicy);
+                    }
+                    return true;
+                });
                 const customModes = groupBy(
-                    modes.custom,
+                    filteredCustomModes,
                     mode => isModeConsideredBuiltIn(mode, this._productService) ? "builtin" : "custom"
                 );
                 const customBuiltinModeActions = customModes.builtin?.map(mode => {
@@ -210,6 +216,7 @@ let ModePickerActionItem = class ModePickerActionItem extends ChatInputPickerAct
             },
             showItemKeybindings: true,
             reporter: {
+                id: "ChatModePicker",
                 name: "ChatModePicker",
                 includeOptions: true
             }
@@ -233,6 +240,16 @@ let ModePickerActionItem = class ModePickerActionItem extends ChatInputPickerAct
                 this.renderLabel(this.element);
             }
         }));
+        assignmentService.getTreatment("chat.showOldAskMode").then(showOldAskMode => {
+            assignments.set({
+                showOldAskMode: showOldAskMode === "enabled"
+            }, undefined);
+        });
+        this._register(assignmentService.onDidRefetchAssignments(async () => {
+            assignments.set({
+                showOldAskMode: (await assignmentService.getTreatment("chat.showOldAskMode")) === "enabled"
+            }, undefined);
+        }));
     }
     getModePickerActionBarActions() {
         const menuActions = this.menuService.createMenu(MenuId.ChatModePicker, this.contextKeyService);
@@ -242,28 +259,34 @@ let ModePickerActionItem = class ModePickerActionItem extends ChatInputPickerAct
         menuActions.dispose();
         return menuContributions;
     }
+    render(container) {
+        super.render(container);
+        container.classList.add("chat-mode-picker-item");
+    }
     renderLabel(element) {
         this.setAriaLabelAttributes(element);
         const currentMode = this.delegate.currentMode.get();
-        const isDefault = currentMode.id === ChatMode.Agent.id;
         const state = currentMode.label.get();
         let icon = currentMode.icon.get();
         if (!icon && isModeConsideredBuiltIn(currentMode, this._productService)) {
-            icon = builtinDefaultIcon;
+            icon = builtinDefaultIcon(currentMode);
         }
         const labelElements = [];
+        const collapsed = this.pickerOptions.hideChevrons.get();
         if (icon) {
             labelElements.push(...renderLabelWithIcons(`$(${icon.id})`));
         }
-        if (!isDefault || !icon || !this.pickerOptions.onlyShowIconsForDefaultActions.get()) {
+        if (!collapsed || !icon) {
             labelElements.push($("span.chat-input-picker-label", undefined, state));
         }
-        labelElements.push(...renderLabelWithIcons(`$(chevron-down)`));
+        if (!collapsed) {
+            labelElements.push(...renderLabelWithIcons(`$(chevron-down)`));
+        }
         reset(element, ...labelElements);
         return null;
     }
 };
-ModePickerActionItem = ( __decorate([( __param(3, IActionWidgetService)), ( __param(4, IChatAgentService)), ( __param(5, IKeybindingService)), ( __param(6, IConfigurationService)), ( __param(7, IContextKeyService)), ( __param(8, IChatModeService)), ( __param(9, IMenuService)), ( __param(10, ICommandService)), ( __param(11, IProductService)), ( __param(12, ITelemetryService)), ( __param(13, IOpenerService))], ModePickerActionItem));
+ModePickerActionItem = ( __decorate([( __param(3, IActionWidgetService)), ( __param(4, IChatAgentService)), ( __param(5, IKeybindingService)), ( __param(6, IConfigurationService)), ( __param(7, IContextKeyService)), ( __param(8, IChatModeService)), ( __param(9, IMenuService)), ( __param(10, ICommandService)), ( __param(11, IProductService)), ( __param(12, ITelemetryService)), ( __param(13, IOpenerService)), ( __param(14, IWorkbenchAssignmentService))], ModePickerActionItem));
 function isModeConsideredBuiltIn(mode, productService) {
     if (mode.isBuiltin) {
         return true;
@@ -281,5 +304,22 @@ function isModeConsideredBuiltIn(mode, productService) {
     }
     return !isOrganizationPromptFile(modeUri, mode.source.extensionId, productService);
 }
+function shouldShowBuiltInMode(mode, assignments, agentModeDisabledViaPolicy) {
+    if (mode.id === ChatMode.Edit.id || mode.name.get().toLowerCase() === "edit") {
+        if (mode.id === ChatMode.Edit.id) {
+            return agentModeDisabledViaPolicy;
+        } else {
+            return !agentModeDisabledViaPolicy;
+        }
+    }
+    if (mode.id === ChatMode.Ask.id || mode.name.get().toLowerCase() === "ask") {
+        if (mode.id === ChatMode.Ask.id) {
+            return assignments.showOldAskMode || agentModeDisabledViaPolicy;
+        } else {
+            return !(assignments.showOldAskMode || agentModeDisabledViaPolicy);
+        }
+    }
+    return true;
+}
 
 export { ModePickerActionItem };

package/vscode/src/vs/workbench/contrib/chat/browser/widget/input/modelPickerActionItem.d.ts

@@ -16,6 +16,7 @@ export interface IModelPickerDelegate {
     readonly currentModel: IObservable<ILanguageModelChatMetadataAndIdentifier | undefined>;
     setModel(model: ILanguageModelChatMetadataAndIdentifier): void;
     getModels(): ILanguageModelChatMetadataAndIdentifier[];
+    canManageModels(): boolean;
 }
 /**
  * Action view item for selecting a language model in the chat interface.

package/vscode/src/vs/workbench/contrib/chat/browser/widget/input/modelPickerActionItem2.d.ts

@@ -0,0 +1,28 @@
+import { BaseActionViewItem } from "@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/actionbar/actionViewItems";
+import { IAction } from "@codingame/monaco-vscode-api/vscode/vs/base/common/actions";
+import { IContextKeyService } from "@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.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 { IChatInputPickerOptions } from "./chatInputPickerActionItem.js";
+import { IModelPickerDelegate } from "./modelPickerActionItem.js";
+/**
+ * Enhanced action view item for selecting a language model in the chat interface.
+ *
+ * Wraps a {@link ModelPickerWidget} and adapts it for use in an action bar,
+ * providing curated model suggestions, upgrade prompts, and grouped layout.
+ */
+export declare class EnhancedModelPickerActionItem extends BaseActionViewItem {
+    private readonly pickerOptions;
+    private readonly _contextKeyService;
+    private readonly keybindingService;
+    private readonly _pickerWidget;
+    private readonly _managedHover;
+    constructor(action: IAction, delegate: IModelPickerDelegate, pickerOptions: IChatInputPickerOptions, instantiationService: IInstantiationService, _contextKeyService: IContextKeyService, keybindingService: IKeybindingService);
+    render(container: HTMLElement): void;
+    private _getAnchorElement;
+    openModelPicker(): void;
+    show(): void;
+    private _showPicker;
+    private _updateTooltip;
+    private _getHoverContents;
+}

package/vscode/src/vs/workbench/contrib/chat/browser/widget/input/modelPickerActionItem2.js

@@ -0,0 +1,87 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { getActiveWindow } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { getBaseLayerHoverDelegate } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/hover/hoverDelegate2';
+import { getDefaultHoverDelegate } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/hover/hoverDelegateFactory';
+import { BaseActionViewItem } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/actionbar/actionViewItems';
+import { MutableDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { IContextKeyService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.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 { ModelPickerWidget } from './chatModelPicker.js';
+import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
+
+let EnhancedModelPickerActionItem = class EnhancedModelPickerActionItem extends BaseActionViewItem {
+    constructor(
+        action,
+        delegate,
+        pickerOptions,
+        instantiationService,
+        _contextKeyService,
+        keybindingService
+    ) {
+        super(undefined, action);
+        this.pickerOptions = pickerOptions;
+        this._contextKeyService = _contextKeyService;
+        this.keybindingService = keybindingService;
+        this._managedHover = this._register(( new MutableDisposable()));
+        this._pickerWidget = this._register(instantiationService.createInstance(ModelPickerWidget, delegate));
+        this._pickerWidget.setSelectedModel(delegate.currentModel.get());
+        this._pickerWidget.setHideChevrons(pickerOptions.hideChevrons);
+        this._register(autorun(t => {
+            const model = delegate.currentModel.read(t);
+            this._pickerWidget.setSelectedModel(model);
+            this._updateTooltip();
+        }));
+        this._register(this._pickerWidget.onDidChangeSelection(model => delegate.setModel(model)));
+    }
+    render(container) {
+        this._pickerWidget.render(container);
+        this.element = this._pickerWidget.domNode;
+        this._updateTooltip();
+        container.classList.add("chat-input-picker-item");
+    }
+    _getAnchorElement() {
+        if (this.element && getActiveWindow().document.contains(this.element)) {
+            return this.element;
+        }
+        return this.pickerOptions.getOverflowAnchor?.() ?? this.element;
+    }
+    openModelPicker() {
+        this._showPicker();
+    }
+    show() {
+        this._showPicker();
+    }
+    _showPicker() {
+        this._pickerWidget.show(this._getAnchorElement());
+    }
+    _updateTooltip() {
+        if (!this.element) {
+            return;
+        }
+        const hoverContent = this._getHoverContents();
+        if (typeof hoverContent === "string" && hoverContent) {
+            this._managedHover.value = getBaseLayerHoverDelegate().setupManagedHover(getDefaultHoverDelegate("mouse"), this.element, hoverContent);
+        } else {
+            this._managedHover.clear();
+        }
+    }
+    _getHoverContents() {
+        let label = ( localize(6844, "Pick Model"));
+        const keybindingLabel = this.keybindingService.lookupKeybinding(this._action.id, this._contextKeyService)?.getLabel();
+        if (keybindingLabel) {
+            label += ` (${keybindingLabel})`;
+        }
+        const {
+            statusIcon,
+            tooltip
+        } = this._pickerWidget.selectedModel?.metadata || {};
+        return statusIcon && tooltip ? `${label} • ${tooltip}` : label;
+    }
+};
+EnhancedModelPickerActionItem = ( __decorate([( __param(3, IInstantiationService)), ( __param(4, IContextKeyService)), ( __param(5, IKeybindingService))], EnhancedModelPickerActionItem));
+
+export { EnhancedModelPickerActionItem };

package/vscode/src/vs/workbench/contrib/chat/browser/widget/input/permissionPickerActionItem.d.ts

@@ -0,0 +1,22 @@
+import { IDisposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IObservable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/observable";
+import { IActionWidgetService } from "@codingame/monaco-vscode-api/vscode/vs/platform/actionWidget/browser/actionWidget.service";
+import { IContextKeyService } from "@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service";
+import { IKeybindingService } from "@codingame/monaco-vscode-api/vscode/vs/platform/keybinding/common/keybinding.service";
+import { ITelemetryService } from "@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service";
+import { ChatPermissionLevel } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants";
+import { MenuItemAction } from "@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions";
+import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+import { IDialogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/dialogs/common/dialogs.service";
+import { ChatInputPickerActionViewItem, IChatInputPickerOptions } from "./chatInputPickerActionItem.js";
+export interface IPermissionPickerDelegate {
+    readonly currentPermissionLevel: IObservable<ChatPermissionLevel>;
+    readonly setPermissionLevel: (level: ChatPermissionLevel) => void;
+}
+export declare class PermissionPickerActionItem extends ChatInputPickerActionViewItem {
+    private readonly delegate;
+    private readonly dialogService;
+    constructor(action: MenuItemAction, delegate: IPermissionPickerDelegate, pickerOptions: IChatInputPickerOptions, actionWidgetService: IActionWidgetService, keybindingService: IKeybindingService, contextKeyService: IContextKeyService, telemetryService: ITelemetryService, configurationService: IConfigurationService, dialogService: IDialogService);
+    protected renderLabel(element: HTMLElement): IDisposable | null;
+    refresh(): void;
+}

package/vscode/src/vs/workbench/contrib/chat/browser/widget/input/permissionPickerActionItem.js

@@ -0,0 +1,213 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { $, reset } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { renderLabelWithIcons } 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 { ThemeIcon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/themables';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { IActionWidgetService } from '@codingame/monaco-vscode-api/vscode/vs/platform/actionWidget/browser/actionWidget.service';
+import { IContextKeyService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service';
+import { IKeybindingService } from '@codingame/monaco-vscode-api/vscode/vs/platform/keybinding/common/keybinding.service';
+import { ITelemetryService } from '@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service';
+import { ChatPermissionLevel, ChatConfiguration } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
+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 Severity from '@codingame/monaco-vscode-api/vscode/vs/base/common/severity';
+import { MarkdownString } from '@codingame/monaco-vscode-api/vscode/vs/base/common/htmlContent';
+import { ChatInputPickerActionViewItem } from './chatInputPickerActionItem.js';
+
+const shownWarnings = ( new Set());
+function hasShownElevatedWarning(level) {
+    if (( shownWarnings.has(level))) {
+        return true;
+    }
+    if (level === ChatPermissionLevel.AutoApprove && ( shownWarnings.has(ChatPermissionLevel.Autopilot))) {
+        return true;
+    }
+    return false;
+}
+let PermissionPickerActionItem = class PermissionPickerActionItem extends ChatInputPickerActionViewItem {
+    constructor(
+        action,
+        delegate,
+        pickerOptions,
+        actionWidgetService,
+        keybindingService,
+        contextKeyService,
+        telemetryService,
+        configurationService,
+        dialogService
+    ) {
+        const isAutoApprovePolicyRestricted = () => configurationService.inspect(ChatConfiguration.GlobalAutoApprove).policyValue === false;
+        const isAutopilotEnabled = () => configurationService.getValue(ChatConfiguration.AutopilotEnabled) !== false;
+        const actionProvider = {
+            getActions: () => {
+                const currentLevel = delegate.currentPermissionLevel.get();
+                const policyRestricted = isAutoApprovePolicyRestricted();
+                const actions = [{
+                    ...action,
+                    id: "chat.permissions.default",
+                    label: ( localize(6845, "Default Approvals")),
+                    description: ( localize(6846, "Copilot uses your configured settings")),
+                    icon: ThemeIcon.fromId(Codicon.shield.id),
+                    checked: currentLevel === ChatPermissionLevel.Default,
+                    tooltip: "",
+                    hover: {
+                        content: ( localize(6847, "Use configured approval settings")),
+                        position: pickerOptions.hoverPosition
+                    },
+                    run: async () => {
+                        delegate.setPermissionLevel(ChatPermissionLevel.Default);
+                        if (this.element) {
+                            this.renderLabel(this.element);
+                        }
+                    }
+                }, {
+                    ...action,
+                    id: "chat.permissions.autoApprove",
+                    label: ( localize(6848, "Bypass Approvals")),
+                    description: ( localize(6849, "All tool calls are auto-approved")),
+                    icon: ThemeIcon.fromId(Codicon.warning.id),
+                    checked: currentLevel === ChatPermissionLevel.AutoApprove,
+                    enabled: !policyRestricted,
+                    tooltip: policyRestricted ? ( localize(6850, "Disabled by enterprise policy")) : "",
+                    hover: {
+                        content: policyRestricted ? ( localize(6851, "Disabled by enterprise policy")) : ( localize(6852, "Auto-approve all tool calls and retry on errors")),
+                        position: pickerOptions.hoverPosition
+                    },
+                    run: async () => {
+                        if (!hasShownElevatedWarning(ChatPermissionLevel.AutoApprove)) {
+                            const result = await this.dialogService.prompt({
+                                type: Severity.Warning,
+                                message: ( localize(6853, "Enable Bypass Approvals?")),
+                                buttons: [{
+                                    label: ( localize(6854, "Enable")),
+                                    run: () => true
+                                }, {
+                                    label: ( localize(6855, "Cancel")),
+                                    run: () => false
+                                }],
+                                custom: {
+                                    icon: Codicon.warning,
+                                    markdownDetails: [{
+                                        markdown: ( new MarkdownString(( localize(
+                                            6856,
+                                            "Bypass Approvals will auto-approve all tool calls without asking for confirmation. This includes file edits, terminal commands, and external tool calls."
+                                        ))))
+                                    }]
+                                }
+                            });
+                            if (result.result !== true) {
+                                return;
+                            }
+                            shownWarnings.add(ChatPermissionLevel.AutoApprove);
+                        }
+                        delegate.setPermissionLevel(ChatPermissionLevel.AutoApprove);
+                        if (this.element) {
+                            this.renderLabel(this.element);
+                        }
+                    }
+                }];
+                if (isAutopilotEnabled()) {
+                    actions.push({
+                        ...action,
+                        id: "chat.permissions.autopilot",
+                        label: ( localize(6857, "Autopilot (Preview)")),
+                        description: ( localize(6858, "Autonomously iterates from start to finish")),
+                        icon: ThemeIcon.fromId(Codicon.rocket.id),
+                        checked: currentLevel === ChatPermissionLevel.Autopilot,
+                        enabled: !policyRestricted,
+                        tooltip: policyRestricted ? ( localize(6859, "Disabled by enterprise policy")) : "",
+                        hover: {
+                            content: policyRestricted ? ( localize(6860, "Disabled by enterprise policy")) : ( localize(6861, "Auto-approve all tool calls and continue until the task is done")),
+                            position: pickerOptions.hoverPosition
+                        },
+                        run: async () => {
+                            if (!hasShownElevatedWarning(ChatPermissionLevel.Autopilot)) {
+                                const result = await this.dialogService.prompt({
+                                    type: Severity.Warning,
+                                    message: ( localize(6862, "Enable Autopilot?")),
+                                    buttons: [{
+                                        label: ( localize(6863, "Enable")),
+                                        run: () => true
+                                    }, {
+                                        label: ( localize(6864, "Cancel")),
+                                        run: () => false
+                                    }],
+                                    custom: {
+                                        icon: Codicon.rocket,
+                                        markdownDetails: [{
+                                            markdown: ( new MarkdownString(( localize(
+                                                6865,
+                                                "Autopilot will auto-approve all tool calls and continue working autonomously until the task is complete. The agent will make decisions on your behalf without asking for confirmation.\n\nYou can stop the agent at any time by clicking the stop button. This applies to the current session only."
+                                            ))))
+                                        }]
+                                    }
+                                });
+                                if (result.result !== true) {
+                                    return;
+                                }
+                                shownWarnings.add(ChatPermissionLevel.Autopilot);
+                            }
+                            delegate.setPermissionLevel(ChatPermissionLevel.Autopilot);
+                            if (this.element) {
+                                this.renderLabel(this.element);
+                            }
+                        }
+                    });
+                }
+                return actions;
+            }
+        };
+        super(action, {
+            actionProvider,
+            reporter: {
+                id: "ChatPermissionPicker",
+                name: "ChatPermissionPicker",
+                includeOptions: true
+            },
+            listOptions: {
+                descriptionBelow: true,
+                minWidth: 255
+            }
+        }, pickerOptions, actionWidgetService, keybindingService, contextKeyService, telemetryService);
+        this.delegate = delegate;
+        this.dialogService = dialogService;
+    }
+    renderLabel(element) {
+        this.setAriaLabelAttributes(element);
+        const level = this.delegate.currentPermissionLevel.get();
+        let icon;
+        let label;
+        switch (level) {
+        case ChatPermissionLevel.Autopilot:
+            icon = Codicon.rocket;
+            label = ( localize(6866, "Autopilot (Preview)"));
+            break;
+        case ChatPermissionLevel.AutoApprove:
+            icon = Codicon.warning;
+            label = ( localize(6867, "Bypass Approvals"));
+            break;
+        default:
+            icon = Codicon.shield;
+            label = ( localize(6868, "Default Approvals"));
+            break;
+        }
+        const labelElements = [];
+        labelElements.push(...renderLabelWithIcons(`$(${icon.id})`));
+        labelElements.push($("span.chat-input-picker-label", undefined, label));
+        labelElements.push(...renderLabelWithIcons(`$(chevron-down)`));
+        reset(element, ...labelElements);
+        element.classList.toggle("warning", level === ChatPermissionLevel.Autopilot);
+        element.classList.toggle("info", level === ChatPermissionLevel.AutoApprove);
+        return null;
+    }
+    refresh() {
+        if (this.element) {
+            this.renderLabel(this.element);
+        }
+    }
+};
+PermissionPickerActionItem = ( __decorate([( __param(3, IActionWidgetService)), ( __param(4, IKeybindingService)), ( __param(5, IContextKeyService)), ( __param(6, ITelemetryService)), ( __param(7, IConfigurationService)), ( __param(8, IDialogService))], PermissionPickerActionItem));
+
+export { PermissionPickerActionItem };

package/vscode/src/vs/workbench/contrib/chat/browser/widget/input/sessionTargetPickerActionItem.d.ts

@@ -43,5 +43,6 @@ export declare class SessionTypePickerActionItem extends ChatInputPickerActionVi
         order: number;
     };
     protected _getSessionDescription(sessionTypeItem: ISessionTypeItem): string | undefined;
+    render(container: HTMLElement): void;
     protected renderLabel(element: HTMLElement): IDisposable | null;
 }