@codingame/monaco-vscode-katex-common 26.2.1 → 27.0.0

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

@@ -1,12 +1,24 @@
 import { IAction } from "@codingame/monaco-vscode-api/vscode/vs/base/common/actions";
+import { IActionWidgetService } from "@codingame/monaco-vscode-api/vscode/vs/platform/actionWidget/browser/actionWidget.service";
 import { IActionWidgetDropdownAction } from "../../../../../../platform/actionWidget/browser/actionWidgetDropdown.js";
+import { MenuItemAction } from "@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions";
+import { ICommandService } from "@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands.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 { IOpenerService } from "@codingame/monaco-vscode-api/vscode/vs/platform/opener/common/opener.service";
+import { ITelemetryService } from "@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service";
+import { IChatSessionsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService.service";
 import { AgentSessionProviders } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentSessions";
+import { ISessionTypePickerDelegate } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat";
+import { IChatInputPickerOptions } from "./chatInputPickerActionItem.js";
 import { ISessionTypeItem, SessionTypePickerActionItem } from "./sessionTargetPickerActionItem.js";
 /**
  * Action view item for delegating to a remote session (Background or Cloud).
  * This picker allows switching to remote execution providers when the session is not empty.
  */
 export declare class DelegationSessionPickerActionItem extends SessionTypePickerActionItem {
+    private readonly _isSessionsWindow;
+    constructor(action: MenuItemAction, chatSessionPosition: "sidebar" | "editor", delegate: ISessionTypePickerDelegate, pickerOptions: IChatInputPickerOptions, actionWidgetService: IActionWidgetService, keybindingService: IKeybindingService, contextKeyService: IContextKeyService, chatSessionsService: IChatSessionsService, commandService: ICommandService, openerService: IOpenerService, telemetryService: ITelemetryService);
     protected _run(sessionTypeItem: ISessionTypeItem): void;
     protected _getSelectedSessionType(): AgentSessionProviders | undefined;
     protected _isSessionTypeEnabled(type: AgentSessionProviders): boolean;
@@ -16,7 +28,6 @@ export declare class DelegationSessionPickerActionItem extends SessionTypePicker
         order: number;
         showHeader: boolean;
     };
-    protected _getSessionDescription(sessionTypeItem: ISessionTypeItem): string | undefined;
     protected _getLearnMore(): IAction;
     protected _getAdditionalActions(): IActionWidgetDropdownAction[];
 }

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

@@ -1,12 +1,49 @@
 
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
 import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
 import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
 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 { ICommandService } from '@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands.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 { IOpenerService } from '@codingame/monaco-vscode-api/vscode/vs/platform/opener/common/opener.service';
+import { ITelemetryService } from '@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service';
+import { IsSessionsWindowContext } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/contextkeys';
+import { IChatSessionsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService.service';
 import { ACTION_ID_NEW_CHAT } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/actions/chatActions';
 import { getAgentSessionProvider, AgentSessionProviders, getAgentCanContinueIn, isFirstPartyAgentSessionProvider } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentSessions';
 import { SessionTypePickerActionItem } from './sessionTargetPickerActionItem.js';
 
-class DelegationSessionPickerActionItem extends SessionTypePickerActionItem {
+let DelegationSessionPickerActionItem = class DelegationSessionPickerActionItem extends SessionTypePickerActionItem {
+    constructor(
+        action,
+        chatSessionPosition,
+        delegate,
+        pickerOptions,
+        actionWidgetService,
+        keybindingService,
+        contextKeyService,
+        chatSessionsService,
+        commandService,
+        openerService,
+        telemetryService
+    ) {
+        super(
+            action,
+            chatSessionPosition,
+            delegate,
+            pickerOptions,
+            actionWidgetService,
+            keybindingService,
+            contextKeyService,
+            chatSessionsService,
+            commandService,
+            openerService,
+            telemetryService
+        );
+        this._isSessionsWindow = IsSessionsWindowContext.getValue(contextKeyService) === true;
+    }
     _run(sessionTypeItem) {
         if (this.delegate.setPendingDelegationTarget) {
             this.delegate.setPendingDelegationTarget(sessionTypeItem.type);
@@ -25,15 +62,22 @@ class DelegationSessionPickerActionItem extends SessionTypePickerActionItem {
     _isSessionTypeEnabled(type) {
         const allContributions = this.chatSessionsService.getAllChatSessionContributions();
         const contribution = allContributions.find(contribution => getAgentSessionProvider(contribution.type) === type);
-        if (this.delegate.getActiveSessionProvider() !== AgentSessionProviders.Local) {
+        const activeProvider = this.delegate.getActiveSessionProvider();
+        if (!this._isSessionsWindow && activeProvider !== AgentSessionProviders.Local) {
             return false;
         }
-        if (contribution && !contribution.canDelegate && this.delegate.getActiveSessionProvider() !== type ) {
+        if (this._isSessionsWindow && activeProvider !== AgentSessionProviders.Background) {
+            return false;
+        }
+        if (contribution && !contribution.canDelegate && activeProvider !== type ) {
             return false;
         }
         return this._getSelectedSessionType() !== type;
     }
     _isVisible(type) {
+        if (this._isSessionsWindow && type === AgentSessionProviders.Local) {
+            return false;
+        }
         if (this.delegate.getActiveSessionProvider() === type) {
             return true;
         }
@@ -42,29 +86,22 @@ class DelegationSessionPickerActionItem extends SessionTypePickerActionItem {
     _getSessionCategory(sessionTypeItem) {
         if (isFirstPartyAgentSessionProvider(sessionTypeItem.type)) {
             return {
-                label: ( localize(6181, "Continue In")),
+                label: ( localize(6731, "Continue In")),
                 order: 1,
                 showHeader: true
             };
         }
         return {
-            label: ( localize(6182, "Continue In (Third Party)")),
+            label: ( localize(6732, "Continue In (Third Party)")),
             order: 2,
             showHeader: false
         };
     }
-    _getSessionDescription(sessionTypeItem) {
-        const allContributions = this.chatSessionsService.getAllChatSessionContributions();
-        const contribution = allContributions.find(
-            contribution => getAgentSessionProvider(contribution.type) === sessionTypeItem.type
-        );
-        return contribution?.name ? `@${contribution.name}` : undefined;
-    }
     _getLearnMore() {
         const learnMoreUrl = "https://aka.ms/vscode-continue-chat-in";
         return {
             id: "workbench.action.chat.agentOverview.learnMoreHandOff",
-            label: ( localize(6183, "Learn about agent handoff...")),
+            label: ( localize(6733, "Learn about agent handoff...")),
             tooltip: learnMoreUrl,
             class: undefined,
             enabled: true,
@@ -74,10 +111,13 @@ class DelegationSessionPickerActionItem extends SessionTypePickerActionItem {
         };
     }
     _getAdditionalActions() {
+        if (this._isSessionsWindow) {
+            return [];
+        }
         return [{
             id: "newChatSession",
             class: undefined,
-            label: ( localize(6184, "New Chat Session")),
+            label: ( localize(6734, "New Chat Session")),
             tooltip: "",
             hover: {
                 content: "",
@@ -87,7 +127,7 @@ class DelegationSessionPickerActionItem extends SessionTypePickerActionItem {
             icon: Codicon.plus,
             enabled: true,
             category: {
-                label: ( localize(6185, "New Chat Session")),
+                label: ( localize(6735, "New Chat Session")),
                 order: 0,
                 showHeader: false
             },
@@ -97,6 +137,7 @@ class DelegationSessionPickerActionItem extends SessionTypePickerActionItem {
             }
         }];
     }
-}
+};
+DelegationSessionPickerActionItem = ( __decorate([( __param(4, IActionWidgetService)), ( __param(5, IKeybindingService)), ( __param(6, IContextKeyService)), ( __param(7, IChatSessionsService)), ( __param(8, ICommandService)), ( __param(9, IOpenerService)), ( __param(10, ITelemetryService))], DelegationSessionPickerActionItem));
 
 export { DelegationSessionPickerActionItem };

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

@@ -16,6 +16,7 @@ import { IChatModeService } from "@codingame/monaco-vscode-api/vscode/vs/workben
 import { Target } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/service/promptsService";
 import { ChatInputPickerActionViewItem, IChatInputPickerOptions } 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";
 export interface IModePickerDelegate {
     readonly currentMode: IObservable<IChatMode>;
     readonly sessionResource: () => URI | undefined;
@@ -30,12 +31,7 @@ export declare class ModePickerActionItem extends ChatInputPickerActionViewItem
     private readonly contextKeyService;
     private readonly menuService;
     private readonly _productService;
-    constructor(action: MenuItemAction, delegate: IModePickerDelegate, pickerOptions: IChatInputPickerOptions, actionWidgetService: IActionWidgetService, chatAgentService: IChatAgentService, keybindingService: IKeybindingService, configurationService: IConfigurationService, contextKeyService: IContextKeyService, chatModeService: IChatModeService, menuService: IMenuService, commandService: ICommandService, _productService: IProductService, telemetryService: ITelemetryService, openerService: IOpenerService);
+    constructor(action: MenuItemAction, delegate: IModePickerDelegate, pickerOptions: IChatInputPickerOptions, actionWidgetService: IActionWidgetService, chatAgentService: IChatAgentService, keybindingService: IKeybindingService, configurationService: IConfigurationService, contextKeyService: IContextKeyService, chatModeService: IChatModeService, menuService: IMenuService, commandService: ICommandService, _productService: IProductService, telemetryService: ITelemetryService, openerService: IOpenerService, assignmentService: IWorkbenchAssignmentService);
     private getModePickerActionBarActions;
     protected renderLabel(element: HTMLElement): IDisposable | null;
 }
-/**
- * Returns true if the mode is the built-in 'implement' mode from the chat extension.
- * This mode is hidden from the mode picker but available for handoffs.
- */
-export declare function isBuiltinImplementMode(mode: IChatMode, productService: IProductService): boolean;

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

@@ -28,9 +28,22 @@ import { getOpenChatActionIdForMode } from '@codingame/monaco-vscode-api/vscode/
 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 +59,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(6751, "Built-In")),
             order: 0
         };
         const customCategory = {
-            label: ( localize(6202, "Custom")),
+            label: ( localize(6752, "Custom")),
             order: 1
         };
         const policyDisabledCategory = {
-            label: ( localize(6203, "Managed by your organization")),
+            label: ( localize(6753, "Managed by your organization")),
             order: 999,
             showHeader: true
         };
@@ -73,11 +90,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(6754, "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(6755, "Edit {0} agent", mode.label.get()));
                     }
                     const modeResource = mode.uri;
                     toolbarActions.push({
@@ -90,27 +107,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 +147,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 +183,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 +215,7 @@ let ModePickerActionItem = class ModePickerActionItem extends ChatInputPickerAct
             },
             showItemKeybindings: true,
             reporter: {
+                id: "ChatModePicker",
                 name: "ChatModePicker",
                 includeOptions: true
             }
@@ -233,6 +239,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);
@@ -249,7 +265,7 @@ let ModePickerActionItem = class ModePickerActionItem extends ChatInputPickerAct
         const state = currentMode.label.get();
         let icon = currentMode.icon.get();
         if (!icon && isModeConsideredBuiltIn(currentMode, this._productService)) {
-            icon = builtinDefaultIcon;
+            icon = builtinDefaultIcon(currentMode);
         }
         const labelElements = [];
         if (icon) {
@@ -263,7 +279,7 @@ let ModePickerActionItem = class ModePickerActionItem extends ChatInputPickerAct
         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 +297,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,86 @@
+
+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._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(6756, "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/sessionTargetPickerActionItem.js

@@ -17,11 +17,11 @@ import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/in
 import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
 
 const firstPartyCategory = {
-    label: ( localize(6218, "Agent Types")),
+    label: ( localize(6757, "Agent Types")),
     order: 1
 };
 const otherCategory = {
-    label: ( localize(6219, "Other")),
+    label: ( localize(6758, "Other")),
     order: 2
 };
 let SessionTypePickerActionItem = class SessionTypePickerActionItem extends ChatInputPickerActionViewItem {
@@ -81,6 +81,7 @@ let SessionTypePickerActionItem = class SessionTypePickerActionItem extends Chat
             actionBarActionProvider,
             showItemKeybindings: true,
             reporter: {
+                id: "ChatSessionTypePicker",
                 name: `ChatSessionTypePicker`,
                 includeOptions: true
             }
@@ -132,7 +133,7 @@ let SessionTypePickerActionItem = class SessionTypePickerActionItem extends Chat
         const learnMoreUrl = "https://code.visualstudio.com/docs/copilot/agents/overview";
         return {
             id: "workbench.action.chat.agentOverview.learnMore",
-            label: ( localize(6220, "Learn about agent types...")),
+            label: ( localize(6759, "Learn about agent types...")),
             tooltip: learnMoreUrl,
             class: undefined,
             enabled: true,
@@ -168,7 +169,10 @@ let SessionTypePickerActionItem = class SessionTypePickerActionItem extends Chat
         return true;
     }
     _isSessionTypeEnabled(type) {
-        return true;
+        if (type === AgentSessionProviders.Local) {
+            return true;
+        }
+        return !!this.chatSessionsService.getChatSessionContribution(type);
     }
     _getSessionCategory(sessionTypeItem) {
         return isFirstPartyAgentSessionProvider(sessionTypeItem.type) ? firstPartyCategory : otherCategory;
@@ -183,7 +187,7 @@ let SessionTypePickerActionItem = class SessionTypePickerActionItem extends Chat
         const icon = getAgentSessionProviderIcon(currentType ?? AgentSessionProviders.Local);
         const labelElements = [];
         labelElements.push(...renderLabelWithIcons(`$(${icon.id})`));
-        if (currentType !== AgentSessionProviders.Local || !this.pickerOptions.onlyShowIconsForDefaultActions.get()) {
+        if (!this.pickerOptions.onlyShowIconsForDefaultActions.get()) {
             labelElements.push($("span.chat-input-picker-label", undefined, label));
         }
         labelElements.push(...renderLabelWithIcons(`$(chevron-down)`));

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

@@ -48,10 +48,10 @@ let WorkspacePickerActionItem = class WorkspacePickerActionItem extends ChatInpu
                 actions.push({
                     ...action,
                     id: "workspace.openFolder",
-                    label: ( localize(6221, "Open Folder...")),
+                    label: ( localize(6760, "Open Folder...")),
                     checked: false,
                     enabled: true,
-                    tooltip: ( localize(6222, "Open Folder...")),
+                    tooltip: ( localize(6761, "Open Folder...")),
                     run: async () => {
                         this.commandService.executeCommand(this.delegate.openFolderCommand);
                     }
@@ -67,6 +67,7 @@ let WorkspacePickerActionItem = class WorkspacePickerActionItem extends ChatInpu
             actionBarActionProvider,
             showItemKeybindings: false,
             reporter: {
+                id: "ChatWorkspacePicker",
                 name: "ChatWorkspacePicker",
                 includeOptions: false
             }
@@ -103,7 +104,7 @@ let WorkspacePickerActionItem = class WorkspacePickerActionItem extends ChatInpu
             labelElements.push($("span.chat-input-picker-label", undefined, label));
         } else {
             labelElements.push(...renderLabelWithIcons(`$(folder)`));
-            labelElements.push($("span.chat-input-picker-label", undefined, ( localize(6223, "Workspace"))));
+            labelElements.push($("span.chat-input-picker-label", undefined, ( localize(6762, "Workspace"))));
         }
         labelElements.push(...renderLabelWithIcons(`$(chevron-down)`));
         reset(element, ...labelElements);