@codingame/monaco-vscode-katex-common 34.1.3 → 35.0.1

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

@@ -1,11 +1,30 @@
 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 { IStringDictionary } from "@codingame/monaco-vscode-api/vscode/vs/base/common/collections";
+import { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
 import { IObservable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/observable";
 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 { ILanguageModelChatMetadataAndIdentifier } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModels";
 import { IChatInputPickerOptions } from "./chatInputPickerActionItem.js";
+/**
+ * Read/write access to a model's configuration (e.g. context size, thinking
+ * effort). Implemented either by the global {@link ILanguageModelsService} or by
+ * a per-editor override layer so that one editor's changes do not sync to other
+ * already-open editors. Structurally satisfied by `ILanguageModelsService`.
+ */
+export interface IModelConfigurationAccess {
+    getModelConfiguration(modelId: string): IStringDictionary<unknown> | undefined;
+    setModelConfiguration(modelId: string, values: IStringDictionary<unknown>): Promise<void>;
+    getModelConfigurationActions(modelId: string): IAction[];
+    /**
+     * Fires when this access layer's configuration changes (e.g. user picks a
+     * new context size). Implementations that always read the global value can
+     * omit this and rely on `ILanguageModelsService.onDidChangeLanguageModels`.
+     */
+    readonly onDidChange?: Event<string>;
+}
 export interface IModelPickerDelegate {
     readonly currentModel: IObservable<ILanguageModelChatMetadataAndIdentifier | undefined>;
     setModel(model: ILanguageModelChatMetadataAndIdentifier): void;
@@ -14,6 +33,34 @@ export interface IModelPickerDelegate {
     showManageModelsAction(): boolean;
     showUnavailableFeatured(): boolean;
     showFeatured(): boolean;
+    /**
+     * Whether the synthetic "Auto" model is available for the current session,
+     * so it can fall back to Auto. Defaults to `true` when omitted. When this
+     * returns `false` and {@link getModels} is empty, the picker shows a
+     * "No models available" entry (and an upgrade prompt for Copilot Free /
+     * Student users) instead of an Auto entry.
+     */
+    showAutoModel?(): boolean;
+    /**
+     * The id of the current chat session, used to correlate model-picker
+     * changes with the session in telemetry. Matches the `chatSessionId`
+     * reported by other chat telemetry events (e.g. the chat request event).
+     * Returns `undefined` when no session is active.
+     */
+    getChatSessionId?(): string | undefined;
+    /**
+     * UI hint flag controlling whether the picker shows the cache-break hint.
+     * Returns `true` when the session has likely warmed the prompt cache (e.g. it
+     * has sent a request), inferred from request history / session status rather
+     * than the provider's actual cache state — so it does not account for cache
+     * expiry or a cache that was already reset. Defaults to `false` when omitted.
+     */
+    isCacheWarm?(): boolean;
+    /**
+     * Per-editor model configuration access. When omitted, the picker reads and
+     * writes configuration through the global {@link ILanguageModelsService}.
+     */
+    readonly modelConfiguration?: IModelConfigurationAccess;
 }
 /**
  * Action view item for selecting a language model in the chat interface.
@@ -33,6 +80,19 @@ export declare class ModelPickerActionItem extends BaseActionViewItem {
     openModelPicker(): void;
     show(): void;
     setEnabled(enabled: boolean): void;
+    /**
+     * Whether the picker has no usable model because the workspace is untrusted
+     * (Restricted Mode). Lets a host (e.g. the sessions picker) keep the picker
+     * visible to surface the "Models" placeholder and Trust Workspace action
+     * instead of hiding it as an empty/no-model picker.
+     */
+    isRestrictedMode(): boolean;
+    /**
+     * Whether the picker has no usable model because Chat still needs sign-in /
+     * setup. Like {@link isRestrictedMode}, lets a host keep the picker visible to
+     * surface the "Models" placeholder and Sign In action.
+     */
+    isSetupRequired(): boolean;
     private _showPicker;
     private _updateTooltip;
     private _getHoverContents;

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

@@ -58,6 +58,12 @@ let ModelPickerActionItem = class ModelPickerActionItem extends BaseActionViewIt
     setEnabled(enabled) {
         this._pickerWidget.setEnabled(enabled);
     }
+    isRestrictedMode() {
+        return this._pickerWidget.isRestrictedMode();
+    }
+    isSetupRequired() {
+        return this._pickerWidget.isSetupRequired();
+    }
     _showPicker() {
         this._pickerWidget.show(this._getAnchorElement());
     }
@@ -66,19 +72,24 @@ let ModelPickerActionItem = class ModelPickerActionItem extends BaseActionViewIt
         if (!target) {
             return;
         }
-        const hoverContent = this._getHoverContents();
-        if (typeof hoverContent === "string" && hoverContent) {
-            this._managedHover.value = getBaseLayerHoverDelegate().setupManagedHover(getDefaultHoverDelegate("mouse"), target, hoverContent);
-        } else {
-            this._managedHover.clear();
-        }
+        this._managedHover.value = getBaseLayerHoverDelegate().setupManagedHover(getDefaultHoverDelegate("mouse"), target, () => this._getHoverContents());
     }
     _getHoverContents() {
-        let label = ( localize(7774, "Pick Model"));
+        let label = ( localize(8354, "Models"));
         const keybindingLabel = this.keybindingService.lookupKeybinding(this._action.id, this._contextKeyService)?.getLabel();
         if (keybindingLabel) {
             label += ` (${keybindingLabel})`;
         }
+        if (this._pickerWidget.isRestrictedMode()) {
+            return localize(
+                8355,
+                "{0} • Unavailable while in Restricted mode. Trust Workspace to enable models.",
+                label
+            );
+        }
+        if (this._pickerWidget.isSetupRequired()) {
+            return localize(8356, "{0} • Sign in to GitHub Copilot to choose a model.", label);
+        }
         const {
             statusIcon,
             tooltip

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

@@ -1,6 +1,7 @@
 import { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
 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 { ThemeIcon } from "@codingame/monaco-vscode-api/vscode/vs/base/common/themables";
 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";
@@ -10,6 +11,7 @@ import { IChatSessionProviderOptionItem } from "@codingame/monaco-vscode-api/vsc
 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 { IHoverService } from "@codingame/monaco-vscode-api/vscode/vs/platform/hover/browser/hover.service";
 import { ChatInputPickerActionViewItem, IChatInputPickerOptions } from "./chatInputPickerActionItem.js";
 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";
@@ -23,20 +25,66 @@ export interface IExtensionPermissionState {
 export interface IPermissionPickerDelegate {
     readonly currentPermissionLevel: IObservable<ChatPermissionLevel>;
     readonly setPermissionLevel: (level: ChatPermissionLevel) => void;
+    /**
+     * The ordered set of permission levels the picker should offer. When
+     * omitted, the built-in Default/Bypass/Autopilot set is used. Agent-host
+     * sessions override this to Default/Bypass (Autopilot lives on the
+     * orthogonal mode axis there).
+     */
+    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;
     /**
      * When defined and returns a non-empty state, the picker shows the extension-contributed
      * items in place of the built-in {@link ChatPermissionLevel} items.
      */
     readonly getExtensionPermissions?: () => IExtensionPermissionState | undefined;
     readonly setExtensionPermission?: (groupId: string, item: IChatSessionProviderOptionItem) => void;
+    readonly getPermissionLevelHover?: (level: ChatPermissionLevel, meta: IPermissionLevelMeta) => string | undefined;
+    /**
+     * Whether the experimental "Sandboxing for terminal" toggle may be shown on
+     * the Default Approvals option. The toggle is specific to the local harness
+     * (which runs the built-in terminal tool); agent-host harnesses such as
+     * Copilot CLI and Claude Code do not implement this and never show it.
+     * Evaluated each time the picker opens so a harness switch is reflected.
+     */
+    readonly isSandboxToggleApplicable?: () => boolean;
+}
+interface IPermissionLevelMeta {
+    readonly id: string;
+    readonly label: string;
+    readonly shortLabel: string;
+    readonly detail: string;
+    readonly icon: ThemeIcon;
+    readonly description: string;
+    /** Elevated levels are disabled when enterprise policy turns off auto-approval and need a warning dialog. */
+    readonly elevated: boolean;
 }
 export declare class PermissionPickerActionItem extends ChatInputPickerActionViewItem {
     private readonly delegate;
+    private readonly configurationService;
     private readonly dialogService;
+    private readonly hoverService;
     private readonly _onDidDispose;
     readonly onDidDispose: Event<void>;
-    constructor(action: MenuItemAction, delegate: IPermissionPickerDelegate, pickerOptions: IChatInputPickerOptions, actionWidgetService: IActionWidgetService, keybindingService: IKeybindingService, contextKeyService: IContextKeyService, telemetryService: ITelemetryService, configurationService: IConfigurationService, dialogService: IDialogService, openerService: IOpenerService, storageService: IStorageService);
+    private _currentTooltip;
+    private _hoverElement;
+    private readonly _hover;
+    constructor(action: MenuItemAction, delegate: IPermissionPickerDelegate, pickerOptions: IChatInputPickerOptions, actionWidgetService: IActionWidgetService, keybindingService: IKeybindingService, contextKeyService: IContextKeyService, telemetryService: ITelemetryService, configurationService: IConfigurationService, dialogService: IDialogService, openerService: IOpenerService, storageService: IStorageService, hoverService: IHoverService);
+    private isSandboxingEnabled;
+    private isSandboxToggleSettingEnabled;
+    /**
+     * Whether the sandbox toggle should surface for the current harness: the
+     * experimental setting must be on and the delegate must opt in (only the
+     * local harness does).
+     */
+    private isSandboxToggleAvailable;
     protected renderLabel(element: HTMLElement): IDisposable | null;
     refresh(): void;
     dispose(): void;
 }
+export {};

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

@@ -4,25 +4,75 @@ import { $, reset } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/do
 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 { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { MutableDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { isWindows } from '@codingame/monaco-vscode-api/vscode/vs/base/common/platform';
 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 { ChatConfiguration, ChatPermissionLevel } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
+import { ChatPermissionLevel, ChatConfiguration } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
 import { SessionType } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService';
 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 { ChatInputPickerActionViewItem } from './chatInputPickerActionItem.js';
 import { IOpenerService } from '@codingame/monaco-vscode-api/vscode/vs/platform/opener/common/opener.service';
 import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
 import { IStorageService } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service';
 import { maybeConfirmElevatedPermissionLevel } from '../../../common/chatPermissionWarnings.js';
+import { AgentSandboxSettingId, AgentSandboxEnabledValue, isAgentSandboxEnabledValue } from '@codingame/monaco-vscode-api/vscode/vs/platform/sandbox/common/settings';
 
+const DEFAULT_PERMISSION_LEVELS = [
+    ChatPermissionLevel.Default,
+    ChatPermissionLevel.AutoApprove,
+    ChatPermissionLevel.Autopilot
+];
+function getPermissionLevelMeta(level) {
+    switch (level) {
+    case ChatPermissionLevel.AutoApprove:
+        return {
+            id: "chat.permissions.autoApprove",
+            label: ( localize(8357, "Bypass Approvals")),
+            shortLabel: ( localize(8358, "Bypass Approvals")),
+            detail: ( localize(8359, "All tool calls are auto-approved")),
+            icon: ThemeIcon.fromId(Codicon.warning.id),
+            description: ( localize(8360, "Auto-approve all tool calls and retry on errors")),
+            elevated: true
+        };
+    case ChatPermissionLevel.Autopilot:
+        return {
+            id: "chat.permissions.autopilot",
+            label: ( localize(8361, "Autopilot (Preview)")),
+            shortLabel: ( localize(8362, "Autopilot (Preview)")),
+            detail: ( localize(8363, "Autonomously iterates from start to finish")),
+            icon: ThemeIcon.fromId(Codicon.rocket.id),
+            description: ( localize(
+                8364,
+                "Auto-approve all tool calls and continue until the task is done. Autopilot may increase costs."
+            )),
+            elevated: true
+        };
+    case ChatPermissionLevel.Default:
+    default:
+        return {
+            id: "chat.permissions.default",
+            label: ( localize(8365, "Default Approvals")),
+            shortLabel: ( localize(8366, "Default Approvals")),
+            detail: ( localize(8367, "Copilot uses your configured settings")),
+            icon: ThemeIcon.fromId(Codicon.shield.id),
+            description: ( localize(8368, "Use configured approval settings")),
+            elevated: false
+        };
+    }
+}
 function sanitizeIdSegment(value) {
     return value.replace(/[^a-zA-Z0-9_-]/g, "_");
 }
+function getSandboxEnabledSettingId() {
+    return isWindows ? AgentSandboxSettingId.AgentSandboxWindowsEnabled : AgentSandboxSettingId.AgentSandboxEnabled;
+}
 let PermissionPickerActionItem = class PermissionPickerActionItem extends ChatInputPickerActionViewItem {
     constructor(
         action,
@@ -35,7 +85,8 @@ let PermissionPickerActionItem = class PermissionPickerActionItem extends ChatIn
         configurationService,
         dialogService,
         openerService,
-        storageService
+        storageService,
+        hoverService
     ) {
         const isAutoApprovePolicyRestricted = () => configurationService.inspect(ChatConfiguration.GlobalAutoApprove).policyValue === false;
         const actionProvider = {
@@ -52,7 +103,7 @@ let PermissionPickerActionItem = class PermissionPickerActionItem extends ChatIn
                         icon: item.icon,
                         checked: ext.selectedId === item.id,
                         enabled: !item.locked,
-                        tooltip: item.locked ? ( localize(7775, "This option is locked")) : "",
+                        tooltip: item.locked ? ( localize(8369, "This option is locked")) : "",
                         hover: item.description ? {
                             content: item.description
                         } : undefined,
@@ -66,70 +117,55 @@ let PermissionPickerActionItem = class PermissionPickerActionItem extends ChatIn
                 }
                 const currentLevel = delegate.currentPermissionLevel.get();
                 const policyRestricted = isAutoApprovePolicyRestricted();
-                const actions = [{
-                    ...action,
-                    id: "chat.permissions.default",
-                    label: ( localize(7776, "Default Approvals")),
-                    detail: ( localize(7777, "Copilot uses your configured settings")),
-                    icon: ThemeIcon.fromId(Codicon.shield.id),
-                    checked: currentLevel === ChatPermissionLevel.Default,
-                    tooltip: "",
-                    hover: {
-                        content: ( localize(7778, "Use configured approval settings"))
-                    },
-                    run: async () => {
-                        delegate.setPermissionLevel(ChatPermissionLevel.Default);
-                        if (this.element) {
-                            this.renderLabel(this.element);
-                        }
+                const sandboxToggleEnabled = this.isSandboxToggleAvailable();
+                const setSandboxEnabled = async enableSandbox => {
+                    const target = enableSandbox ? AgentSandboxEnabledValue.On : AgentSandboxEnabledValue.Off;
+                    if (this.isSandboxingEnabled() !== enableSandbox) {
+                        await configurationService.updateValue(getSandboxEnabledSettingId(), target);
                     }
-                }, {
-                    ...action,
-                    id: "chat.permissions.autoApprove",
-                    label: ( localize(7779, "Bypass Approvals")),
-                    detail: ( localize(7780, "All tool calls are auto-approved")),
-                    icon: ThemeIcon.fromId(Codicon.warning.id),
-                    checked: currentLevel === ChatPermissionLevel.AutoApprove,
-                    enabled: !policyRestricted,
-                    tooltip: policyRestricted ? ( localize(7781, "Disabled by enterprise policy")) : "",
-                    hover: {
-                        content: policyRestricted ? ( localize(7782, "Disabled by enterprise policy")) : ( localize(7783, "Auto-approve all tool calls and retry on errors"))
-                    },
-                    run: async () => {
-                        if (!(await maybeConfirmElevatedPermissionLevel(ChatPermissionLevel.AutoApprove, this.dialogService, storageService))) {
-                            return;
-                        }
-                        delegate.setPermissionLevel(ChatPermissionLevel.AutoApprove);
-                        if (this.element) {
-                            this.renderLabel(this.element);
+                };
+                const levels = delegate.availableLevels ?? DEFAULT_PERMISSION_LEVELS;
+                const actions = ( levels.map(level => {
+                    const meta = getPermissionLevelMeta(level);
+                    const disabledByPolicy = meta.elevated && policyRestricted;
+                    const hover = disabledByPolicy ? ( localize(8370, "Disabled by enterprise policy")) : delegate.getPermissionLevelHover?.(level, meta) ?? meta.description;
+                    const inlineToggle = sandboxToggleEnabled && level === ChatPermissionLevel.Default ? {
+                        label: ( localize(8371, "Sandboxing for terminal")),
+                        title: ( localize(
+                            8372,
+                            "Run terminal commands inside a sandbox that restricts file system and network access"
+                        )),
+                        checked: this.isSandboxingEnabled(),
+                        onChange: checked => {
+                            void setSandboxEnabled(checked);
                         }
-                    }
-                }];
-                actions.push({
-                    ...action,
-                    id: "chat.permissions.autopilot",
-                    label: ( localize(7784, "Autopilot (Preview)")),
-                    detail: ( localize(7785, "Autonomously iterates from start to finish")),
-                    icon: ThemeIcon.fromId(Codicon.rocket.id),
-                    checked: currentLevel === ChatPermissionLevel.Autopilot,
-                    enabled: !policyRestricted,
-                    tooltip: policyRestricted ? ( localize(7786, "Disabled by enterprise policy")) : "",
-                    hover: {
-                        content: policyRestricted ? ( localize(7787, "Disabled by enterprise policy")) : ( localize(
-                            7788,
-                            "Auto-approve all tool calls and continue until the task is done. Autopilot may increase costs."
-                        ))
-                    },
-                    run: async () => {
-                        if (!(await maybeConfirmElevatedPermissionLevel(ChatPermissionLevel.Autopilot, this.dialogService, storageService))) {
-                            return;
-                        }
-                        delegate.setPermissionLevel(ChatPermissionLevel.Autopilot);
-                        if (this.element) {
-                            this.renderLabel(this.element);
+                    } : undefined;
+                    return {
+                        ...action,
+                        id: meta.id,
+                        label: meta.label,
+                        detail: meta.detail,
+                        icon: meta.icon,
+                        checked: currentLevel === level,
+                        enabled: !disabledByPolicy,
+                        inlineToggle,
+                        tooltip: disabledByPolicy ? ( localize(8373, "Disabled by enterprise policy")) : "",
+                        hover: {
+                            content: hover
+                        },
+                        run: async () => {
+                            if (meta.elevated && !(await maybeConfirmElevatedPermissionLevel(level, this.dialogService, storageService, {
+                                defaultSettingKey: delegate.defaultSettingKey
+                            }))) {
+                                return;
+                            }
+                            delegate.setPermissionLevel(level);
+                            if (this.element) {
+                                this.renderLabel(this.element);
+                            }
                         }
-                    }
-                });
+                    };
+                }));
                 return actions;
             }
         };
@@ -137,8 +173,8 @@ let PermissionPickerActionItem = class PermissionPickerActionItem extends ChatIn
             actionProvider,
             actionBarActions: [{
                 id: "chat.permissions.learnMore",
-                label: ( localize(7789, "Learn more about permissions")),
-                tooltip: ( localize(7789, "Learn more about permissions")),
+                label: ( localize(8374, "Learn more about permissions")),
+                tooltip: ( localize(8374, "Learn more about permissions")),
                 class: undefined,
                 enabled: true,
                 run: async () => {
@@ -158,34 +194,48 @@ let PermissionPickerActionItem = class PermissionPickerActionItem extends ChatIn
             }
         }, pickerOptions, actionWidgetService, keybindingService, contextKeyService, telemetryService);
         this.delegate = delegate;
+        this.configurationService = configurationService;
         this.dialogService = dialogService;
+        this.hoverService = hoverService;
         this._onDidDispose = this._register(( new Emitter()));
         this.onDidDispose = this._onDidDispose.event;
+        this._currentTooltip = "";
+        this._hover = this._register(( new MutableDisposable()));
+        this._register(configurationService.onDidChangeConfiguration(e => {
+            if ((e.affectsConfiguration(getSandboxEnabledSettingId()) || e.affectsConfiguration(ChatConfiguration.PermissionsSandboxToggleEnabled)) && this.element) {
+                this.renderLabel(this.element);
+            }
+        }));
+    }
+    isSandboxingEnabled() {
+        const value = this.configurationService.getValue(getSandboxEnabledSettingId());
+        return isAgentSandboxEnabledValue(value);
+    }
+    isSandboxToggleSettingEnabled() {
+        return this.configurationService.getValue(ChatConfiguration.PermissionsSandboxToggleEnabled) === true;
+    }
+    isSandboxToggleAvailable() {
+        return this.isSandboxToggleSettingEnabled() && this.delegate.isSandboxToggleApplicable?.() === true;
     }
     renderLabel(element) {
         this.setAriaLabelAttributes(element);
         const ext = this.delegate.getExtensionPermissions?.();
         let icon;
         let label;
+        let tooltip;
         const level = this.delegate.currentPermissionLevel.get();
         if (ext && ext.items.length > 0) {
             const selected = ext.items.find(i => i.id === ext.selectedId) ?? ext.items.find(i => i.default) ?? ext.items[0];
             icon = selected.icon ?? Codicon.lock;
             label = selected.name;
+            tooltip = selected.description ?? selected.name;
         } else {
-            switch (level) {
-            case ChatPermissionLevel.Autopilot:
-                icon = Codicon.rocket;
-                label = ( localize(7790, "Autopilot (Preview)"));
-                break;
-            case ChatPermissionLevel.AutoApprove:
-                icon = Codicon.warning;
-                label = ( localize(7791, "Bypass Approvals"));
-                break;
-            default:
-                icon = Codicon.shield;
-                label = ( localize(7792, "Default Approvals"));
-                break;
+            const meta = getPermissionLevelMeta(level);
+            icon = meta.icon;
+            label = meta.shortLabel;
+            tooltip = this.delegate.getPermissionLevelHover?.(level, meta) ?? meta.description;
+            if (level === ChatPermissionLevel.Default && this.isSandboxToggleAvailable() && this.isSandboxingEnabled()) {
+                label = ( localize(8375, "Default Approvals (Sandboxed)"));
             }
         }
         const labelElements = [];
@@ -194,7 +244,17 @@ let PermissionPickerActionItem = class PermissionPickerActionItem extends ChatIn
         reset(element, ...labelElements);
         element.classList.toggle("warning", !ext && level === ChatPermissionLevel.Autopilot);
         element.classList.toggle("info", !ext && level === ChatPermissionLevel.AutoApprove);
-        element.setAttribute("aria-label", ( localize(7793, "Permission picker, {0}", label)));
+        this._currentTooltip = tooltip;
+        element.setAttribute(
+            "aria-label",
+            !ext && this.delegate.getPermissionLevelHover ? ( localize(8376, "Permission picker, {0}, {1}", label, tooltip)) : ( localize(8377, "Permission picker, {0}", label))
+        );
+        if (this._hoverElement !== element) {
+            this._hoverElement = element;
+            this._hover.value = this.hoverService.setupDelayedHover(element, () => ({
+                content: this._currentTooltip
+            }));
+        }
         return null;
     }
     refresh() {
@@ -210,6 +270,6 @@ let PermissionPickerActionItem = class PermissionPickerActionItem extends ChatIn
         super.dispose();
     }
 };
-PermissionPickerActionItem = ( __decorate([( __param(3, IActionWidgetService)), ( __param(4, IKeybindingService)), ( __param(5, IContextKeyService)), ( __param(6, ITelemetryService)), ( __param(7, IConfigurationService)), ( __param(8, IDialogService)), ( __param(9, IOpenerService)), ( __param(10, IStorageService))], PermissionPickerActionItem));
+PermissionPickerActionItem = ( __decorate([( __param(3, IActionWidgetService)), ( __param(4, IKeybindingService)), ( __param(5, IContextKeyService)), ( __param(6, ITelemetryService)), ( __param(7, IConfigurationService)), ( __param(8, IDialogService)), ( __param(9, IOpenerService)), ( __param(10, IStorageService)), ( __param(11, IHoverService))], PermissionPickerActionItem));
 
 export { PermissionPickerActionItem };

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

@@ -11,6 +11,7 @@ import { IOpenerService } from "@codingame/monaco-vscode-api/vscode/vs/platform/
 import { ITelemetryService } from "@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service";
 import { IChatEntitlementService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/chat/common/chatEntitlementService.service";
 import { IChatSessionsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService.service";
+import { ILanguageModelsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModels.service";
 import { AgentSessionTarget } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentSessions";
 import { ChatInputPickerActionViewItem, IChatInputPickerOptions } from "./chatInputPickerActionItem.js";
 import { ISessionTypePickerDelegate } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat";
@@ -32,9 +33,10 @@ export declare class SessionTypePickerActionItem extends ChatInputPickerActionVi
     protected readonly commandService: ICommandService;
     protected readonly openerService: IOpenerService;
     protected readonly chatEntitlementService: IChatEntitlementService;
+    protected readonly languageModelsService: ILanguageModelsService;
     protected readonly configurationService: IConfigurationService;
     private _sessionTypeItems;
-    constructor(action: MenuItemAction, chatSessionPosition: "sidebar" | "editor", delegate: ISessionTypePickerDelegate, pickerOptions: IChatInputPickerOptions, actionWidgetService: IActionWidgetService, keybindingService: IKeybindingService, contextKeyService: IContextKeyService, chatSessionsService: IChatSessionsService, commandService: ICommandService, openerService: IOpenerService, telemetryService: ITelemetryService, chatEntitlementService: IChatEntitlementService, configurationService: IConfigurationService);
+    constructor(action: MenuItemAction, chatSessionPosition: "sidebar" | "editor", delegate: ISessionTypePickerDelegate, pickerOptions: IChatInputPickerOptions, actionWidgetService: IActionWidgetService, keybindingService: IKeybindingService, contextKeyService: IContextKeyService, chatSessionsService: IChatSessionsService, commandService: ICommandService, openerService: IOpenerService, telemetryService: ITelemetryService, chatEntitlementService: IChatEntitlementService, languageModelsService: ILanguageModelsService, configurationService: IConfigurationService);
     protected _run(sessionTypeItem: ISessionTypeItem): void;
     protected _getSelectedSessionType(): AgentSessionTarget | undefined;
     protected _getAdditionalActions(): IActionWidgetDropdownAction[];
@@ -42,23 +44,13 @@ export declare class SessionTypePickerActionItem extends ChatInputPickerActionVi
     private _updateAgentSessionItems;
     /**
      * The default session type for the picker when no session is yet active.
-     * Defaults to {@link AgentSessionProviders.Local} but is overridden to
-     * {@link AgentSessionProviders.AgentHostCopilot} when the experimental
-     * {@link ChatConfiguration.AgentHostDefaultChatProvider} setting is enabled
-     * and that provider is registered.
+     * Defaults to {@link AgentSessionProviders.Local} but is overridden based on
+     * the experimental {@link ChatConfiguration.EditorDefaultProvider} setting
+     * when the selected provider is registered.
      */
     protected _getDefaultSessionType(): AgentSessionTarget;
-    protected _isVisible(_type: AgentSessionTarget): boolean;
+    protected _isVisible(type: AgentSessionTarget): boolean;
     protected _isSessionTypeEnabled(type: AgentSessionTarget): boolean;
-    /**
-     * Whether the given session type is locked behind a plan upgrade for the
-     * current user's entitlement. The cloud agent is not available to Copilot
-     * Free or Copilot Student (EDU) users, so it is shown greyed out with an
-     * Upgrade prompt instead of being selectable.
-     */
-    protected _isLockedForEntitlement(type: AgentSessionTarget): boolean;
-    private _getUpgradeDescription;
-    private _getUpgradeHover;
     protected _getSessionCategory(sessionTypeItem: ISessionTypeItem): {
         label: string;
         order: number;