@codingame/monaco-vscode-katex-common 25.1.1 → 26.0.0

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

@@ -1,4 +1,3 @@
-import { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
 import { Disposable, IDisposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
 import { ContextKeyExpression } from "@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey";
 import { IContextKeyService } from "@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service";
@@ -11,10 +10,6 @@ export interface IChatInputPartWidget extends IDisposable {
      * The DOM node of the widget.
      */
     readonly domNode: HTMLElement;
-    /**
-     * Fired when the height of the widget changes.
-     */
-    readonly onDidChangeHeight: Event<void>;
     /**
      * The current height of the widget in pixels.
      */
@@ -42,8 +37,6 @@ export declare class ChatInputPartWidgetController extends Disposable {
     private readonly container;
     private readonly contextKeyService;
     private readonly instantiationService;
-    private readonly _onDidChangeHeight;
-    readonly onDidChangeHeight: Event<void>;
     private readonly renderedWidgets;
     constructor(container: HTMLElement, contextKeyService: IContextKeyService, instantiationService: IInstantiationService);
     private update;

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

@@ -1,6 +1,5 @@
 
 import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
-import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
 import { Disposable, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
 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';
@@ -10,7 +9,11 @@ const ChatInputPartWidgetsRegistry = new (class {
         this.widgets = [];
     }
     register(id, ctor, when) {
-        this.widgets.push({ id, ctor: ctor, when });
+        this.widgets.push({
+            id,
+            ctor: ctor,
+            when
+        });
     }
     getWidgets() {
         return this.widgets;
@@ -22,8 +25,6 @@ let ChatInputPartWidgetController = class ChatInputPartWidgetController extends
         this.container = container;
         this.contextKeyService = contextKeyService;
         this.instantiationService = instantiationService;
-        this._onDidChangeHeight = this._register(( new Emitter()));
-        this.onDidChangeHeight = this._onDidChangeHeight.event;
         this.renderedWidgets = ( new Map());
         this.update();
         this._register(this.contextKeyService.onDidChangeContext(e => {
@@ -62,12 +63,14 @@ let ChatInputPartWidgetController = class ChatInputPartWidgetController extends
                 const disposables = ( new DisposableStore());
                 const widget = this.instantiationService.createInstance(descriptor.ctor);
                 disposables.add(widget);
-                disposables.add(widget.onDidChangeHeight(() => this._onDidChangeHeight.fire()));
-                this.renderedWidgets.set(descriptor.id, { descriptor, widget, disposables });
+                this.renderedWidgets.set(descriptor.id, {
+                    descriptor,
+                    widget,
+                    disposables
+                });
                 this.container.appendChild(widget.domNode);
             }
         }
-        this._onDidChangeHeight.fire();
     }
     get height() {
         let total = 0;
@@ -85,9 +88,6 @@ let ChatInputPartWidgetController = class ChatInputPartWidgetController extends
         super.dispose();
     }
 };
-ChatInputPartWidgetController = ( __decorate([
-    ( __param(1, IContextKeyService)),
-    ( __param(2, IInstantiationService))
-], ChatInputPartWidgetController));
+ChatInputPartWidgetController = ( __decorate([( __param(1, IContextKeyService)), ( __param(2, IInstantiationService))], ChatInputPartWidgetController));
 
 export { ChatInputPartWidgetController, ChatInputPartWidgetsRegistry };

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

@@ -0,0 +1,34 @@
+import { IHoverPositionOptions } from "@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/hover/hover";
+import { IAction } from "@codingame/monaco-vscode-api/vscode/vs/base/common/actions";
+import { IObservable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/observable";
+import { ActionWidgetDropdownActionViewItem } from "../../../../../../platform/actions/browser/actionWidgetDropdownActionViewItem.js";
+import { IActionWidgetService } from "@codingame/monaco-vscode-api/vscode/vs/platform/actionWidget/browser/actionWidget.service";
+import { IActionWidgetDropdownOptions } from "../../../../../../platform/actionWidget/browser/actionWidgetDropdown.js";
+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 { IChatExecuteActionContext } from "../../actions/chatExecuteActions.js";
+export interface IChatInputPickerOptions {
+    /**
+     * Provides a fallback anchor element when the picker's own element
+     * is not available in the DOM (e.g., when inside an overflow menu).
+     */
+    readonly getOverflowAnchor?: () => HTMLElement | undefined;
+    readonly actionContext?: IChatExecuteActionContext;
+    readonly onlyShowIconsForDefaultActions: IObservable<boolean>;
+    readonly hoverPosition?: IHoverPositionOptions;
+}
+/**
+ * Base class for chat input picker action items (model picker, mode picker, session target picker).
+ * Provides common anchor resolution logic for dropdown positioning.
+ */
+export declare abstract class ChatInputPickerActionViewItem extends ActionWidgetDropdownActionViewItem {
+    protected readonly pickerOptions: IChatInputPickerOptions;
+    constructor(action: IAction, actionWidgetOptions: Omit<IActionWidgetDropdownOptions, "label" | "labelRenderer">, pickerOptions: IChatInputPickerOptions, actionWidgetService: IActionWidgetService, keybindingService: IKeybindingService, contextKeyService: IContextKeyService, telemetryService: ITelemetryService);
+    /**
+     * Returns the anchor element for the dropdown.
+     * Falls back to the overflow anchor if this element is not in the DOM.
+     */
+    protected getAnchorElement(): HTMLElement;
+    render(container: HTMLElement): void;
+}

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

@@ -0,0 +1,55 @@
+
+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 '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { ActionWidgetDropdownActionViewItem } from '../../../../../../platform/actions/browser/actionWidgetDropdownActionViewItem.js';
+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 { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
+
+let ChatInputPickerActionViewItem = class ChatInputPickerActionViewItem extends ActionWidgetDropdownActionViewItem {
+    constructor(
+        action,
+        actionWidgetOptions,
+        pickerOptions,
+        actionWidgetService,
+        keybindingService,
+        contextKeyService,
+        telemetryService
+    ) {
+        const optionsWithAnchor = {
+            ...actionWidgetOptions,
+            getAnchor: () => this.getAnchorElement()
+        };
+        super(
+            action,
+            optionsWithAnchor,
+            actionWidgetService,
+            keybindingService,
+            contextKeyService,
+            telemetryService
+        );
+        this.pickerOptions = pickerOptions;
+        this._register(autorun(reader => {
+            this.pickerOptions.onlyShowIconsForDefaultActions.read(reader);
+            if (this.element) {
+                this.renderLabel(this.element);
+            }
+        }));
+    }
+    getAnchorElement() {
+        if (this.element && getActiveWindow().document.contains(this.element)) {
+            return this.element;
+        }
+        return this.pickerOptions.getOverflowAnchor?.() ?? this.element;
+    }
+    render(container) {
+        super.render(container);
+        container.classList.add("chat-input-picker-item");
+    }
+};
+ChatInputPickerActionViewItem = ( __decorate([( __param(3, IActionWidgetService)), ( __param(4, IKeybindingService)), ( __param(5, IContextKeyService)), ( __param(6, ITelemetryService))], ChatInputPickerActionViewItem));
+
+export { ChatInputPickerActionViewItem };

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

@@ -2,8 +2,9 @@ import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/l
 import { IObservable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/observable";
 import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
 import { IStorageService } from "@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service";
-import { UserSelectedTools } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/participants/chatAgents";
 import { IChatMode } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatModes";
+import { ILanguageModelChatMetadataAndIdentifier } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModels";
+import { UserSelectedTools } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/participants/chatAgents";
 import { IToolAndToolSetEnablementMap } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService";
 import { ILanguageModelToolsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService.service";
 export declare enum ToolsScope {
@@ -14,13 +15,16 @@ export declare enum ToolsScope {
 }
 export declare class ChatSelectedTools extends Disposable {
     private readonly _mode;
+    private readonly languageModel;
     private readonly _toolsService;
     private readonly _instantiationService;
     private readonly _globalState;
     private readonly _sessionStates;
-    constructor(_mode: IObservable<IChatMode>, _toolsService: ILanguageModelToolsService, _storageService: IStorageService, _instantiationService: IInstantiationService);
+    private readonly _currentTools;
+    constructor(_mode: IObservable<IChatMode>, languageModel: IObservable<ILanguageModelChatMetadataAndIdentifier | undefined>, _toolsService: ILanguageModelToolsService, _storageService: IStorageService, _instantiationService: IInstantiationService);
     /**
      * All tools and tool sets with their enabled state.
+     * Tools are filtered based on the current model context.
      */
     readonly entriesMap: IObservable<IToolAndToolSetEnablementMap>;
     readonly userSelectedTools: IObservable<UserSelectedTools>;

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

@@ -9,32 +9,33 @@ import { observableMemento } from '@codingame/monaco-vscode-api/vscode/vs/platfo
 import { StorageScope, StorageTarget } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage';
 import { IStorageService } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service';
 import { ChatModeKind } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
-import { ToolSet } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService';
-import { ILanguageModelToolsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService.service';
 import { PromptsStorage } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/service/promptsService';
+import { isToolSet } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService';
+import { ILanguageModelToolsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService.service';
 import { PromptFileRewriter } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/promptSyntax/promptFileRewriter';
 import { ObservableMap } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/map';
 import { derived } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/derived';
 
 var ToolEnablementStates;
-(function (ToolEnablementStates) {
+(function(ToolEnablementStates) {
     function fromMap(map) {
-        const toolSets = ( new Map()), tools = ( new Map());
+        const toolSets = ( new Map()),
+              tools = ( new Map());
         for (const [entry, enabled] of map.entries()) {
-            if (entry instanceof ToolSet) {
+            if (isToolSet(entry)) {
                 toolSets.set(entry.id, enabled);
-            }
-            else {
+            } else {
                 tools.set(entry.id, enabled);
             }
         }
-        return { toolSets, tools };
+        return {
+            toolSets,
+            tools
+        };
     }
     ToolEnablementStates.fromMap = fromMap;
     function isStoredDataV1(data) {
-        return isObject(data) && data.version === undefined
-            && (data.disabledTools === undefined || Array.isArray(data.disabledTools))
-            && (data.disabledToolSets === undefined || Array.isArray(data.disabledToolSets));
+        return isObject(data) && data.version === undefined && (data.disabledTools === undefined || Array.isArray(data.disabledTools)) && (data.disabledToolSets === undefined || Array.isArray(data.disabledToolSets));
     }
     function isStoredDataV2(data) {
         return isObject(data) && data.version === 2 && Array.isArray(data.toolSetEntries) && Array.isArray(data.toolEntries);
@@ -43,17 +44,23 @@ var ToolEnablementStates;
         try {
             const parsed = JSON.parse(storage);
             if (isStoredDataV2(parsed)) {
-                return { toolSets: ( new Map(parsed.toolSetEntries)), tools: ( new Map(parsed.toolEntries)) };
-            }
-            else if (isStoredDataV1(parsed)) {
+                return {
+                    toolSets: ( new Map(parsed.toolSetEntries)),
+                    tools: ( new Map(parsed.toolEntries))
+                };
+            } else if (isStoredDataV1(parsed)) {
                 const toolSetEntries = parsed.disabledToolSets?.map(id => [id, false]);
                 const toolEntries = parsed.disabledTools?.map(id => [id, false]);
-                return { toolSets: ( new Map(toolSetEntries)), tools: ( new Map(toolEntries)) };
+                return {
+                    toolSets: ( new Map(toolSetEntries)),
+                    tools: ( new Map(toolEntries))
+                };
             }
-        }
-        catch {
-        }
-        return { toolSets: ( new Map()), tools: ( new Map()) };
+        } catch {}
+        return {
+            toolSets: ( new Map()),
+            tools: ( new Map())
+        };
     }
     ToolEnablementStates.fromStorage = fromStorage;
     function toStorage(state) {
@@ -67,39 +74,47 @@ var ToolEnablementStates;
     ToolEnablementStates.toStorage = toStorage;
 })(ToolEnablementStates || (ToolEnablementStates = {}));
 var ToolsScope;
-(function (ToolsScope) {
+(function(ToolsScope) {
     ToolsScope[ToolsScope["Global"] = 0] = "Global";
     ToolsScope[ToolsScope["Session"] = 1] = "Session";
     ToolsScope[ToolsScope["Agent"] = 2] = "Agent";
     ToolsScope[ToolsScope["Agent_ReadOnly"] = 3] = "Agent_ReadOnly";
 })(ToolsScope || (ToolsScope = {}));
 let ChatSelectedTools = class ChatSelectedTools extends Disposable {
-    constructor(_mode, _toolsService, _storageService, _instantiationService) {
+    constructor(
+        _mode,
+        languageModel,
+        _toolsService,
+        _storageService,
+        _instantiationService
+    ) {
         super();
         this._mode = _mode;
+        this.languageModel = languageModel;
         this._toolsService = _toolsService;
         this._instantiationService = _instantiationService;
         this._sessionStates = ( new ObservableMap());
         this.entriesMap = derived(r => {
             const map = ( new Map());
+            const lm = this.languageModel.read(r)?.metadata;
             const currentMode = this._mode.read(r);
             let currentMap = this._sessionStates.observable.read(r).get(currentMode.id);
             if (!currentMap && currentMode.kind === ChatModeKind.Agent) {
                 const modeTools = currentMode.customTools?.read(r);
                 if (modeTools) {
                     const target = currentMode.target?.read(r);
-                    currentMap = ToolEnablementStates.fromMap(this._toolsService.toToolAndToolSetEnablementMap(modeTools, target));
+                    currentMap = ToolEnablementStates.fromMap(this._toolsService.toToolAndToolSetEnablementMap(modeTools, target, lm));
                 }
             }
             if (!currentMap) {
                 currentMap = this._globalState.read(r);
             }
-            for (const tool of this._toolsService.toolsObservable.read(r)) {
+            for (const tool of this._currentTools.read(r)) {
                 if (tool.canBeReferencedInPrompt) {
                     map.set(tool, currentMap.tools.get(tool.id) !== false);
                 }
             }
-            for (const toolSet of this._toolsService.toolSets.read(r)) {
+            for (const toolSet of this._toolsService.getToolSetsForModel(lm, r)) {
                 const toolSetEnabled = currentMap.toolSets.get(toolSet.id) !== false;
                 map.set(toolSet, toolSetEnabled);
                 for (const tool of toolSet.getTools(r)) {
@@ -112,19 +127,25 @@ let ChatSelectedTools = class ChatSelectedTools extends Disposable {
             const result = {};
             const map = this.entriesMap.read(r);
             for (const [item, enabled] of map) {
-                if (!(item instanceof ToolSet)) {
+                if (!isToolSet(item)) {
                     result[item.id] = enabled;
                 }
             }
             return result;
         });
         const globalStateMemento = observableMemento({
-            key: 'chat/selectedTools',
-            defaultValue: { toolSets: ( new Map()), tools: ( new Map()) },
+            key: "chat/selectedTools",
+            defaultValue: {
+                toolSets: ( new Map()),
+                tools: ( new Map())
+            },
             fromStorage: ToolEnablementStates.fromStorage,
             toStorage: ToolEnablementStates.toStorage
         });
-        this._globalState = this._store.add(globalStateMemento(StorageScope.PROFILE, StorageTarget.MACHINE, _storageService));
+        this._globalState = this._store.add(
+            globalStateMemento(StorageScope.PROFILE, StorageTarget.MACHINE, _storageService)
+        );
+        this._currentTools = ( ( languageModel.map(lm => _toolsService.observeTools(lm?.metadata))).map((o, r) => o.read(r)));
     }
     get entriesScope() {
         const mode = this._mode.get();
@@ -153,8 +174,7 @@ let ChatSelectedTools = class ChatSelectedTools extends Disposable {
             if (mode.source?.storage !== PromptsStorage.extension) {
                 this.updateCustomModeTools(mode.uri.get(), enablementMap);
                 return;
-            }
-            else {
+            } else {
                 this._sessionStates.set(mode.id, ToolEnablementStates.fromMap(enablementMap));
                 return;
             }
@@ -165,10 +185,6 @@ let ChatSelectedTools = class ChatSelectedTools extends Disposable {
         await this._instantiationService.createInstance(PromptFileRewriter).openAndRewriteTools(uri, enablementMap, CancellationToken.None);
     }
 };
-ChatSelectedTools = ( __decorate([
-    ( __param(1, ILanguageModelToolsService)),
-    ( __param(2, IStorageService)),
-    ( __param(3, IInstantiationService))
-], ChatSelectedTools));
+ChatSelectedTools = ( __decorate([( __param(2, ILanguageModelToolsService)), ( __param(3, IStorageService)), ( __param(4, IInstantiationService))], ChatSelectedTools));
 
 export { ChatSelectedTools, ToolsScope };

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

@@ -0,0 +1,22 @@
+import { IAction } from "@codingame/monaco-vscode-api/vscode/vs/base/common/actions";
+import { IActionWidgetDropdownAction } from "../../../../../../platform/actionWidget/browser/actionWidgetDropdown.js";
+import { AgentSessionProviders } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentSessions";
+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 {
+    protected _run(sessionTypeItem: ISessionTypeItem): void;
+    protected _getSelectedSessionType(): AgentSessionProviders | undefined;
+    protected _isSessionTypeEnabled(type: AgentSessionProviders): boolean;
+    protected _isVisible(type: AgentSessionProviders): boolean;
+    protected _getSessionCategory(sessionTypeItem: ISessionTypeItem): {
+        label: string;
+        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

@@ -0,0 +1,102 @@
+
+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 { 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 {
+    _run(sessionTypeItem) {
+        if (this.delegate.setPendingDelegationTarget) {
+            this.delegate.setPendingDelegationTarget(sessionTypeItem.type);
+        }
+        if (this.element) {
+            this.renderLabel(this.element);
+        }
+    }
+    _getSelectedSessionType() {
+        const delegationTarget = this.delegate.getPendingDelegationTarget ? this.delegate.getPendingDelegationTarget() : undefined;
+        if (delegationTarget) {
+            return delegationTarget;
+        }
+        return this.delegate.getActiveSessionProvider();
+    }
+    _isSessionTypeEnabled(type) {
+        const allContributions = this.chatSessionsService.getAllChatSessionContributions();
+        const contribution = allContributions.find(contribution => getAgentSessionProvider(contribution.type) === type);
+        if (this.delegate.getActiveSessionProvider() !== AgentSessionProviders.Local) {
+            return false;
+        }
+        if (contribution && !contribution.canDelegate && this.delegate.getActiveSessionProvider() !== type ) {
+            return false;
+        }
+        return this._getSelectedSessionType() !== type;
+    }
+    _isVisible(type) {
+        if (this.delegate.getActiveSessionProvider() === type) {
+            return true;
+        }
+        return getAgentCanContinueIn(type);
+    }
+    _getSessionCategory(sessionTypeItem) {
+        if (isFirstPartyAgentSessionProvider(sessionTypeItem.type)) {
+            return {
+                label: ( localize(6086, "Continue In")),
+                order: 1,
+                showHeader: true
+            };
+        }
+        return {
+            label: ( localize(6087, "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(6088, "Learn about agent handoff...")),
+            tooltip: learnMoreUrl,
+            class: undefined,
+            enabled: true,
+            run: async () => {
+                await this.openerService.open(( URI.parse(learnMoreUrl)));
+            }
+        };
+    }
+    _getAdditionalActions() {
+        return [{
+            id: "newChatSession",
+            class: undefined,
+            label: ( localize(6089, "New Chat Session")),
+            tooltip: "",
+            hover: {
+                content: "",
+                position: this.pickerOptions.hoverPosition
+            },
+            checked: false,
+            icon: Codicon.plus,
+            enabled: true,
+            category: {
+                label: ( localize(6090, "New Chat Session")),
+                order: 0,
+                showHeader: false
+            },
+            description: this.keybindingService.lookupKeybinding(ACTION_ID_NEW_CHAT)?.getLabel() || undefined,
+            run: async () => {
+                this.commandService.executeCommand(ACTION_ID_NEW_CHAT, this.chatSessionPosition);
+            }
+        }];
+    }
+}
+
+export { DelegationSessionPickerActionItem };

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

@@ -1,7 +1,6 @@
 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 { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
-import { ActionWidgetDropdownActionViewItem } from "../../../../../../platform/actions/browser/actionWidgetDropdownActionViewItem.js";
 import { MenuItemAction } from "@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions";
 import { IMenuService } from "@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions.service";
 import { IActionWidgetService } from "@codingame/monaco-vscode-api/vscode/vs/platform/actionWidget/browser/actionWidget.service";
@@ -10,19 +9,32 @@ import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/pl
 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 { IProductService } from "@codingame/monaco-vscode-api/vscode/vs/platform/product/common/productService.service";
+import { ITelemetryService } from "@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service";
 import { IChatAgentService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/participants/chatAgents.service";
 import { IChatMode } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatModes";
 import { IChatModeService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatModes.service";
+import { ChatInputPickerActionViewItem, IChatInputPickerOptions } from "./chatInputPickerActionItem.js";
+import { IOpenerService } from "@codingame/monaco-vscode-api/vscode/vs/platform/opener/common/opener.service";
 export interface IModePickerDelegate {
     readonly currentMode: IObservable<IChatMode>;
     readonly sessionResource: () => URI | undefined;
+    /**
+     * When set, the mode picker will show custom agents whose target matches this value.
+     * Custom agents without a target are always shown in all session types. If no agents match the target, shows a default "Agent" option.
+     */
+    readonly customAgentTarget?: () => string | undefined;
 }
-export declare class ModePickerActionItem extends ActionWidgetDropdownActionViewItem {
+export declare class ModePickerActionItem extends ChatInputPickerActionViewItem {
     private readonly delegate;
     private readonly contextKeyService;
     private readonly menuService;
-    constructor(action: MenuItemAction, delegate: IModePickerDelegate, actionWidgetService: IActionWidgetService, chatAgentService: IChatAgentService, keybindingService: IKeybindingService, configurationService: IConfigurationService, contextKeyService: IContextKeyService, chatModeService: IChatModeService, menuService: IMenuService, commandService: ICommandService, productService: IProductService);
+    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);
     private getModePickerActionBarActions;
     protected renderLabel(element: HTMLElement): IDisposable | null;
-    render(container: HTMLElement): void;
 }
+/**
+ * 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;