@codingame/monaco-vscode-chat-service-override 37.2.0 → 37.3.1

package/vscode/src/vs/sessions/contrib/providers/copilotChatSessions/browser/mobilePermissionPicker.contribution.d.ts

@@ -0,0 +1 @@
+export {};

package/vscode/src/vs/sessions/contrib/providers/copilotChatSessions/browser/mobilePermissionPicker.contribution.js

@@ -0,0 +1,37 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { IActionViewItemService } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/browser/actionViewItemService.service';
+import { registerWorkbenchContribution2, WorkbenchPhase } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions';
+import { Menus } from '@codingame/monaco-vscode-api/vscode/vs/sessions/browser/menus';
+import { ISessionContext } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionContext.service';
+import { PickerActionViewItem } from './copilotChatSessionsActions.js';
+import { MobilePermissionPicker } from './mobilePermissionPicker.js';
+import { CopilotPermissionPickerDelegate } from './permissionPicker.js';
+
+let CopilotPermissionPickerWebContribution = class CopilotPermissionPickerWebContribution extends Disposable {
+    static {
+        this.ID = "workbench.contrib.copilotPermissionPickerWeb";
+    }
+    constructor(actionViewItemService) {
+        super();
+        this._register(actionViewItemService.register(
+            Menus.NewSessionControl,
+            "sessions.defaultCopilot.permissionPicker",
+            (_action, _options, scopedInstantiationService) => {
+                const {
+                    session
+                } = scopedInstantiationService.invokeFunction(accessor => accessor.get(ISessionContext));
+                const delegate = scopedInstantiationService.createInstance(CopilotPermissionPickerDelegate, session);
+                const picker = scopedInstantiationService.createInstance(MobilePermissionPicker, delegate);
+                return ( new PickerActionViewItem(picker, delegate));
+            }
+        ));
+    }
+};
+CopilotPermissionPickerWebContribution = ( __decorate([( __param(0, IActionViewItemService))], CopilotPermissionPickerWebContribution));
+registerWorkbenchContribution2(
+    CopilotPermissionPickerWebContribution.ID,
+    CopilotPermissionPickerWebContribution,
+    WorkbenchPhase.AfterRestored
+);

package/vscode/src/vs/sessions/contrib/providers/copilotChatSessions/browser/mobilePermissionPicker.d.ts

@@ -0,0 +1,25 @@
+import { IActionWidgetService } from "@codingame/monaco-vscode-api/vscode/vs/platform/actionWidget/browser/actionWidget.service";
+import { IAgentHostEnablementService } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostEnablementService.service";
+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 { IOpenerService } from "@codingame/monaco-vscode-api/vscode/vs/platform/opener/common/opener.service";
+import { IStorageService } from "@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service";
+import { ITelemetryService } from "@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service";
+import { IWorkbenchLayoutService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/layout/browser/layoutService.service";
+import { IPermissionPickerDelegate, PermissionPicker } from "./permissionPicker.js";
+/**
+ * Phone variant of {@link PermissionPicker} that surfaces the available
+ * approval levels (provided by the delegate, defaulting to
+ * Default/Bypass/Autopilot) as a {@link showMobilePickerSheet} bottom sheet
+ * rather than the desktop action-widget popup.
+ *
+ * Falls back to the inherited dropdown when the viewport is not phone
+ * (e.g. user resized past the breakpoint after the picker rendered).
+ */
+export declare class MobilePermissionPicker extends PermissionPicker {
+    private readonly _layoutService;
+    constructor(_delegate: IPermissionPickerDelegate, actionWidgetService: IActionWidgetService, configurationService: IConfigurationService, dialogService: IDialogService, openerService: IOpenerService, storageService: IStorageService, telemetryService: ITelemetryService, hoverService: IHoverService, _layoutService: IWorkbenchLayoutService, agentHostEnablementService: IAgentHostEnablementService);
+    showPicker(): void;
+    protected _showPicker(): void;
+}

package/vscode/src/vs/sessions/contrib/providers/copilotChatSessions/browser/mobilePermissionPicker.js

@@ -0,0 +1,97 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
+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 { IAgentHostEnablementService } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostEnablementService.service';
+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 { IOpenerService } from '@codingame/monaco-vscode-api/vscode/vs/platform/opener/common/opener.service';
+import { IStorageService } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service';
+import { ITelemetryService } from '@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service';
+import { IWorkbenchLayoutService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/layout/browser/layoutService.service';
+import { ChatConfiguration, ChatPermissionLevel } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
+import { PermissionPicker, DEFAULT_PERMISSION_LEVELS } from './permissionPicker.js';
+import { isPhoneLayout } from '@codingame/monaco-vscode-api/vscode/vs/sessions/browser/parts/mobile/mobileLayout';
+import { showMobilePickerSheet } from '@codingame/monaco-vscode-api/vscode/vs/sessions/browser/parts/mobile/mobilePickerSheet';
+
+const LEARN_MORE_ID = "learn-more";
+let MobilePermissionPicker = class MobilePermissionPicker extends PermissionPicker {
+    constructor(
+        _delegate,
+        actionWidgetService,
+        configurationService,
+        dialogService,
+        openerService,
+        storageService,
+        telemetryService,
+        hoverService,
+        _layoutService,
+        agentHostEnablementService
+    ) {
+        super(
+            _delegate,
+            actionWidgetService,
+            configurationService,
+            dialogService,
+            openerService,
+            storageService,
+            telemetryService,
+            hoverService,
+            agentHostEnablementService
+        );
+        this._layoutService = _layoutService;
+    }
+    showPicker() {
+        this._showPicker();
+    }
+    _showPicker() {
+        if (!this._triggerElement || this.actionWidgetService.isVisible || this._isResolving()) {
+            return;
+        }
+        if (!isPhoneLayout(this._layoutService)) {
+            super._showPicker();
+            return;
+        }
+        const policyRestricted = this.configurationService.inspect(ChatConfiguration.GlobalAutoApprove).policyValue === false;
+        const levels = this._delegate.availableLevels ?? DEFAULT_PERMISSION_LEVELS;
+        const items = levels.map(level => {
+            const meta = this._getPermissionLevelMeta(level);
+            return {
+                id: level,
+                label: meta.label,
+                description: meta.detail,
+                icon: meta.icon,
+                checked: this._currentLevel === level,
+                ...(level !== ChatPermissionLevel.Default && policyRestricted ? {
+                    disabled: true
+                } : {})
+            };
+        });
+        items.push({
+            id: LEARN_MORE_ID,
+            label: ( localize(4231, "Learn more about permissions")),
+            icon: Codicon.linkExternal,
+            sectionTitle: ""
+        });
+        const trigger = this._triggerElement;
+        trigger.setAttribute("aria-expanded", "true");
+        showMobilePickerSheet(this._layoutService.mainContainer, ( localize(4232, "Approvals")), items).then(async id => {
+            trigger.setAttribute("aria-expanded", "false");
+            trigger.focus();
+            if (!id) {
+                return;
+            }
+            if (id === LEARN_MORE_ID) {
+                await this.openerService.open(( URI.parse("https://aka.ms/vscode/docs/permissions")));
+                return;
+            }
+            await this._selectLevel(id);
+        });
+    }
+};
+MobilePermissionPicker = ( __decorate([( __param(1, IActionWidgetService)), ( __param(2, IConfigurationService)), ( __param(3, IDialogService)), ( __param(4, IOpenerService)), ( __param(5, IStorageService)), ( __param(6, ITelemetryService)), ( __param(7, IHoverService)), ( __param(8, IWorkbenchLayoutService)), ( __param(9, IAgentHostEnablementService))], MobilePermissionPicker));
+
+export { MobilePermissionPicker };

package/vscode/src/vs/sessions/contrib/providers/copilotChatSessions/browser/modePicker.d.ts

@@ -0,0 +1,74 @@
+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 { IObservable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/observable";
+import { IActionWidgetService } from "@codingame/monaco-vscode-api/vscode/vs/platform/actionWidget/browser/actionWidget.service";
+import { ITelemetryService } from "@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.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 { IChatService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService.service";
+import { IChatSessionsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService.service";
+import { ICommandService } from "@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands.service";
+import type { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import type { ISession } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/session";
+import type { IActiveSession } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/sessionsManagement";
+export declare class ModePickerModel extends Disposable {
+    private readonly chatSessionsService;
+    private readonly chatModeService;
+    private readonly _onDidChange;
+    readonly onDidChange: Event<void>;
+    private readonly _modeChangeListener;
+    private readonly _chatModesDisposable;
+    private _selectedModeId;
+    private _sessionResource;
+    private _chatModes;
+    get selectedMode(): IChatMode;
+    get selectedModeId(): string | undefined;
+    constructor(chatSessionsService: IChatSessionsService, chatModeService: IChatModeService);
+    reset(): void;
+    setSelectedMode(mode: IChatMode): void;
+    setSession(session: ISession | undefined, selectedModeId: string | undefined): void;
+    getAvailableModes(): IChatMode[];
+    private _setSession;
+    private _findModeById;
+}
+/** Retains each surface's model across synchronous toolbar rebuilds. */
+export declare class ScopedModePickerModelCache extends Disposable {
+    private readonly acceptsSession;
+    private readonly entries;
+    constructor(acceptsSession: (session: ISession) => boolean);
+    acquire(session: IObservable<IActiveSession | undefined>, instantiationService: IInstantiationService): IDisposable & {
+        readonly model: ModePickerModel;
+    };
+    private release;
+    dispose(): void;
+}
+/**
+ * A self-contained widget for selecting a chat mode (Agent, custom agents)
+ * for local/Background sessions. Shows only modes whose target matches
+ * the Background session type's customAgentTarget.
+ */
+export declare class ModePicker extends Disposable {
+    private readonly session;
+    private readonly actionWidgetService;
+    private readonly commandService;
+    private readonly telemetryService;
+    private readonly chatService;
+    private readonly _onDidSelect;
+    readonly onDidSelect: Event<IChatMode>;
+    private _triggerElement;
+    private readonly _renderDisposables;
+    private readonly _modePickerModel;
+    constructor(modePickerModel: ModePickerModel, session: IObservable<IActiveSession | undefined>, actionWidgetService: IActionWidgetService, commandService: ICommandService, telemetryService: ITelemetryService, chatService: IChatService);
+    /**
+     * Resets the selected mode back to the default Agent mode.
+     */
+    reset(): void;
+    /**
+     * Renders the mode picker trigger button into the given container.
+     */
+    render(container: HTMLElement): HTMLElement;
+    private _showPicker;
+    private _buildItems;
+    private _selectMode;
+    private _updateTriggerLabel;
+}

package/vscode/src/vs/sessions/contrib/providers/copilotChatSessions/browser/modePicker.js

@@ -0,0 +1,355 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { append, $, EventType, addDisposableListener, EventHelper, clearNode } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { Gesture, EventType as EventType$1 } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/touch';
+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 { Disposable, MutableDisposable, DisposableStore } 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 { IActionWidgetService } from '@codingame/monaco-vscode-api/vscode/vs/platform/actionWidget/browser/actionWidget.service';
+import { ActionListItemKind } from '@codingame/monaco-vscode-api/vscode/vs/platform/actionWidget/browser/actionList';
+import { renderIcon } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/iconLabel/iconLabels';
+import { ITelemetryService } from '@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service';
+import { ChatMode } 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 { reportChatModeChange } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatModeTelemetry';
+import { IChatService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService.service';
+import { IChatSessionsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService.service';
+import { getChatSessionType } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/chatUri';
+import { ICommandService } from '@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands.service';
+import { Target } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/promptTypes';
+import '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/aiCustomization/aiCustomizationManagement';
+import { AICustomizationManagementCommands, AICustomizationManagementSection } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/aiCustomizationWorkspaceService';
+import { reportNewChatPickerClosed } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/chat/browser/newChatPickerTelemetry';
+import { CopilotCLISessionType } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/providers/agentHost/browser/baseAgentHostSessionsProvider';
+import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
+
+let ModePickerModel = class ModePickerModel extends Disposable {
+    get selectedMode() {
+        if (!this._selectedModeId) {
+            return ChatMode.Agent;
+        }
+        return this._findModeById(this._selectedModeId) ?? ChatMode.Agent;
+    }
+    get selectedModeId() {
+        return this._selectedModeId;
+    }
+    constructor(chatSessionsService, chatModeService) {
+        super();
+        this.chatSessionsService = chatSessionsService;
+        this.chatModeService = chatModeService;
+        this._onDidChange = this._register(( new Emitter()));
+        this.onDidChange = this._onDidChange.event;
+        this._modeChangeListener = this._register(( new MutableDisposable()));
+        this._chatModesDisposable = this._register(( new MutableDisposable()));
+        this._selectedModeId = undefined;
+    }
+    reset() {
+        this._selectedModeId = undefined;
+        this._onDidChange.fire();
+    }
+    setSelectedMode(mode) {
+        this._selectedModeId = mode.id;
+        this._onDidChange.fire();
+    }
+    setSession(session, selectedModeId) {
+        if (!session) {
+            if (!this._sessionResource) {
+                return;
+            }
+            this._sessionResource = undefined;
+            this._modeChangeListener.clear();
+            this._chatModesDisposable.value = undefined;
+            this._chatModes = undefined;
+            this._selectedModeId = undefined;
+            this._onDidChange.fire();
+            return;
+        }
+        this._setSession(session, selectedModeId);
+    }
+    getAvailableModes() {
+        const sessionType = this._sessionResource ? getChatSessionType(this._sessionResource) : CopilotCLISessionType.id;
+        const customAgentTarget = this.chatSessionsService.getCustomAgentTargetForSessionType(sessionType);
+        const effectiveTarget = customAgentTarget && customAgentTarget !== Target.Undefined ? customAgentTarget : Target.GitHubCopilot;
+        const result = [ChatMode.Agent];
+        for (const mode of (this._chatModes?.custom ?? [])) {
+            const target = mode.target.get();
+            if (target === effectiveTarget || target === Target.Undefined) {
+                const visibility = mode.visibility?.get();
+                if (visibility && !visibility.userInvocable) {
+                    continue;
+                }
+                result.push(mode);
+            }
+        }
+        return result;
+    }
+    _setSession(session, selectedModeId) {
+        const sessionResource = session.resource;
+        if (this._sessionResource?.toString() === ( sessionResource.toString())) {
+            if (this._selectedModeId !== selectedModeId) {
+                this._selectedModeId = selectedModeId;
+                this._onDidChange.fire();
+            }
+            return;
+        }
+        this._sessionResource = sessionResource;
+        const modes = this.chatModeService.createModes(sessionResource);
+        this._chatModesDisposable.value = modes;
+        this._chatModes = modes;
+        this._modeChangeListener.value = modes.onDidChange(() => {
+            this._onDidChange.fire();
+        });
+        this._selectedModeId = selectedModeId;
+        this._onDidChange.fire();
+    }
+    _findModeById(id) {
+        const mode = this._chatModes?.findModeById(id);
+        if (mode) {
+            return mode;
+        }
+        return undefined;
+    }
+};
+ModePickerModel = ( __decorate([( __param(0, IChatSessionsService)), ( __param(1, IChatModeService))], ModePickerModel));
+class ScopedModePickerModelCache extends Disposable {
+    constructor(acceptsSession) {
+        super();
+        this.acceptsSession = acceptsSession;
+        this.entries = ( new Map());
+    }
+    acquire(session, instantiationService) {
+        let entry = this.entries.get(session);
+        if (!entry) {
+            const store = ( new DisposableStore());
+            const model = store.add(instantiationService.createInstance(ModePickerModel));
+            store.add(autorun(reader => {
+                const scopedSession = session.read(reader);
+                model.setSession(
+                    scopedSession && this.acceptsSession(scopedSession) ? scopedSession : undefined,
+                    scopedSession?.mode.read(reader)?.id
+                );
+            }));
+            entry = {
+                model,
+                store,
+                references: 0,
+                disposalGeneration: 0
+            };
+            this.entries.set(session, entry);
+        }
+        entry.references++;
+        entry.disposalGeneration++;
+        let disposed = false;
+        return {
+            model: entry.model,
+            dispose: () => {
+                if (disposed) {
+                    return;
+                }
+                disposed = true;
+                this.release(session, entry);
+            }
+        };
+    }
+    release(session, entry) {
+        entry.references--;
+        const disposalGeneration = ++entry.disposalGeneration;
+        queueMicrotask(() => {
+            if (entry.references === 0 && entry.disposalGeneration === disposalGeneration && this.entries.get(session) === entry) {
+                this.entries.delete(session);
+                entry.store.dispose();
+            }
+        });
+    }
+    dispose() {
+        for (const entry of ( this.entries.values())) {
+            entry.store.dispose();
+        }
+        this.entries.clear();
+        super.dispose();
+    }
+}
+let ModePicker = class ModePicker extends Disposable {
+    constructor(
+        modePickerModel,
+        session,
+        actionWidgetService,
+        commandService,
+        telemetryService,
+        chatService
+    ) {
+        super();
+        this.session = session;
+        this.actionWidgetService = actionWidgetService;
+        this.commandService = commandService;
+        this.telemetryService = telemetryService;
+        this.chatService = chatService;
+        this._onDidSelect = this._register(( new Emitter()));
+        this.onDidSelect = this._onDidSelect.event;
+        this._renderDisposables = this._register(( new DisposableStore()));
+        this._modePickerModel = modePickerModel;
+        this._register(this._modePickerModel.onDidChange(() => {
+            if (this._triggerElement) {
+                this._updateTriggerLabel();
+            }
+        }));
+    }
+    reset() {
+        this._modePickerModel.reset();
+        this._updateTriggerLabel();
+    }
+    render(container) {
+        this._renderDisposables.clear();
+        const slot = append(container, $(".sessions-chat-picker-slot"));
+        this._renderDisposables.add({
+            dispose: () => slot.remove()
+        });
+        const trigger = append(slot, $("a.action-label"));
+        trigger.tabIndex = 0;
+        trigger.role = "button";
+        this._triggerElement = trigger;
+        this._updateTriggerLabel();
+        this._renderDisposables.add(Gesture.addTarget(trigger));
+        for (const eventType of [EventType.CLICK, EventType$1.Tap]) {
+            this._renderDisposables.add(addDisposableListener(trigger, eventType, e => {
+                EventHelper.stop(e, true);
+                this._showPicker();
+            }));
+        }
+        this._renderDisposables.add(addDisposableListener(trigger, EventType.KEY_DOWN, e => {
+            if (e.key === "Enter" || e.key === " ") {
+                EventHelper.stop(e, true);
+                this._showPicker();
+            }
+        }));
+        return slot;
+    }
+    _showPicker() {
+        if (!this._triggerElement || this.actionWidgetService.isVisible) {
+            return;
+        }
+        const modes = this._modePickerModel.getAvailableModes();
+        const items = this._buildItems(modes);
+        const triggerElement = this._triggerElement;
+        const delegate = {
+            onSelect: item => {
+                this.actionWidgetService.hide();
+                if (item.kind === "mode") {
+                    const activeChat = this.session.get()?.activeChat.get();
+                    const previousModeId = activeChat?.mode.get()?.id;
+                    const previousMode = modes.find(mode => mode.id === previousModeId) ?? ChatMode.Agent;
+                    reportNewChatPickerClosed(this.telemetryService, {
+                        id: "NewChatModePicker",
+                        optionIdBefore: previousMode.id,
+                        optionIdAfter: item.mode.id,
+                        optionLabelBefore: previousMode.label.get(),
+                        optionLabelAfter: item.mode.label.get(),
+                        isPII: true
+                    });
+                    const requestCount = activeChat ? this.chatService.getSession(activeChat.resource)?.getRequests().length ?? 0 : 0;
+                    reportChatModeChange(this.telemetryService, previousMode, item.mode, requestCount);
+                    this._selectMode(item.mode);
+                } else {
+                    this.commandService.executeCommand(
+                        AICustomizationManagementCommands.OpenEditor,
+                        AICustomizationManagementSection.Agents
+                    );
+                }
+            },
+            onHide: () => {
+                triggerElement.focus();
+            }
+        };
+        this.actionWidgetService.show(
+            "localModePicker",
+            false,
+            items,
+            delegate,
+            this._triggerElement,
+            undefined,
+            [],
+            {
+                getAriaLabel: item => item.label ?? "",
+                getWidgetAriaLabel: () => ( localize(4233, "Mode Picker"))
+            }
+        );
+    }
+    _buildItems(modes) {
+        const items = [];
+        const selectedModeId = this._modePickerModel.selectedMode.id;
+        const agentMode = modes[0];
+        items.push({
+            kind: ActionListItemKind.Action,
+            label: agentMode.label.get(),
+            group: {
+                title: "",
+                icon: selectedModeId === agentMode.id ? Codicon.check : Codicon.blank
+            },
+            item: {
+                kind: "mode",
+                mode: agentMode
+            }
+        });
+        const customModes = modes.slice(1);
+        if (customModes.length > 0) {
+            items.push({
+                kind: ActionListItemKind.Separator,
+                label: ""
+            });
+            for (const mode of customModes) {
+                items.push({
+                    kind: ActionListItemKind.Action,
+                    label: mode.label.get(),
+                    group: {
+                        title: "",
+                        icon: selectedModeId === mode.id ? Codicon.check : Codicon.blank
+                    },
+                    item: {
+                        kind: "mode",
+                        mode
+                    }
+                });
+            }
+        }
+        items.push({
+            kind: ActionListItemKind.Separator,
+            label: ""
+        });
+        items.push({
+            kind: ActionListItemKind.Action,
+            label: ( localize(4234, "Configure Custom Agents...")),
+            group: {
+                title: "",
+                icon: Codicon.blank
+            },
+            item: {
+                kind: "configure"
+            }
+        });
+        return items;
+    }
+    _selectMode(mode) {
+        this._modePickerModel.setSelectedMode(mode);
+        this._updateTriggerLabel();
+        this._onDidSelect.fire(mode);
+    }
+    _updateTriggerLabel() {
+        if (!this._triggerElement) {
+            return;
+        }
+        clearNode(this._triggerElement);
+        const selectedMode = this._modePickerModel.selectedMode;
+        const icon = selectedMode.icon.get();
+        if (icon) {
+            append(this._triggerElement, renderIcon(icon));
+        }
+        const labelSpan = append(this._triggerElement, $("span.sessions-chat-dropdown-label"));
+        labelSpan.textContent = selectedMode.label.get();
+        this._triggerElement.ariaLabel = ( localize(4235, "Pick Mode, {0}", selectedMode.label.get()));
+    }
+};
+ModePicker = ( __decorate([( __param(2, IActionWidgetService)), ( __param(3, ICommandService)), ( __param(4, ITelemetryService)), ( __param(5, IChatService))], ModePicker));
+
+export { ModePicker, ModePickerModel, ScopedModePickerModelCache };