@codingame/monaco-vscode-api 37.6.1 → 38.0.0

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

@@ -1,32 +1,49 @@
 
 import { __decorate, __param } from '../../../../../../../../../../external/tslib/tslib.es6.js';
+import { append, $ } from '../../../../../../../base/browser/dom.js';
+import { Button } from '../../../../../../../base/browser/ui/button/button.js';
+import { status } from '../../../../../../../base/browser/ui/aria/aria.js';
+import { SelectBox } from '../../../../../../../base/browser/ui/selectBox/selectBox.js';
+import { ActionBar } from '../../../../../../../base/browser/ui/actionbar/actionbar.js';
+import { toAction } from '../../../../../../../base/common/actions.js';
 import { Codicon } from '../../../../../../../base/common/codicons.js';
 import { Emitter } from '../../../../../../../base/common/event.js';
-import { Disposable, DisposableMap, MutableDisposable } from '../../../../../../../base/common/lifecycle.js';
+import { AnchorPosition } from '../../../../../../../base/common/layout.js';
+import { Disposable, DisposableMap, MutableDisposable, DisposableStore, toDisposable } from '../../../../../../../base/common/lifecycle.js';
 import { ThemeIcon } from '../../../../../../../base/common/themables.js';
 import { localize } from '../../../../../../../nls.js';
 import { ActionListItemKind } from '../../../../../../../platform/actionWidget/browser/actionList.js';
+import { withActionWidgetDropdownMotion } from '../../../../../../../platform/actionWidget/browser/actionWidgetDropdown.js';
 import { TabbedActionListWidget } from '../../../../../../../platform/actionWidget/browser/tabbedActionListWidget.js';
+import { COPILOT_HYDRA_FUSION_MODEL_NAMES, COPILOT_HYDRA_FUSION_MODEL_ID, COPILOT_HYDRA_FUSION_MAX_MODEL_ID } from '../../../../../../../platform/agentHost/common/copilotCliConfig.js';
+import { IConfigurationService } from '../../../../../../../platform/configuration/common/configuration.service.js';
 import { IInstantiationService } from '../../../../../../../platform/instantiation/common/instantiation.js';
+import { IContextViewService } from '../../../../../../../platform/contextview/browser/contextView.service.js';
+import { defaultSelectBoxStyles, defaultButtonStyles } from '../../../../../../../platform/theme/browser/defaultStyles.js';
 import { IOpenerService } from '../../../../../../../platform/opener/common/opener.service.js';
 import { StorageScope, StorageTarget } from '../../../../../../../platform/storage/common/storage.js';
 import { IStorageService } from '../../../../../../../platform/storage/common/storage.service.js';
+import { ChatEntitlement } from '../../../../../../services/chat/common/chatEntitlementService.js';
 import { IChatEntitlementService } from '../../../../../../services/chat/common/chatEntitlementService.service.js';
+import { isUserProvidedModel } from '../../../../common/languageModels.js';
 import { ILanguageModelsService } from '../../../../common/languageModels.service.js';
-import { withChatInputPickerMotion } from '../chatInputPickerActionItem.js';
-import { ModelPickerAutoRow } from './modelPickerAutoRow.js';
+import { ChatConfiguration } from '../../../../common/constants.js';
+import { resolveConfiguredModel } from '../../../../common/modelSelection.js';
+import { getModelConfigProperty, MODEL_CONFIG_GROUP_EFFORT, getModelConfigSummary, getModelConfigDescription } from './modelPickerModelConfig.js';
 import { ModelCard } from './modelPickerCard.js';
 import { getPreferredSpeedVariant } from './modelPickerVariants.js';
-import { getModelBadge } from './modelPickerBadges.js';
-import { getUnavailableReason, createUnavailableModelItem, createModelAction } from './modelPickerItemPrimitives.js';
-import { getModelPickerAccessibilityProvider } from './modelPickerItems.js';
-import { isAutoModel } from './modelPickerPresentation.js';
+import { organizationDefaultLabel, getOrganizationDefaultDescription, getModelBadge } from './modelPickerBadges.js';
+import { requiresNewerVSCode, createUnavailableModelItem, getUnavailableReason, createModelAction } from './modelPickerItemPrimitives.js';
+import { getModelPickerControlModels, getModelPickerAccessibilityProvider } from './modelPickerItems.js';
+import { filterModelPickerControlModelsForEntitlement, filterModelPickerModelsForEntitlement, isAutoModel, isHydraFusionModel, getEnsembleTierLabel, isHydraFusionUpgradeOnly, getHydraFusionTierLabel } from './modelPickerPresentation.js';
 import { hasPromotedModels, MODEL_PICKER_BUILT_IN_DESTINATION, buildModelPickerDestinations, buildModelPickerSections, getModelProviderLabel } from './modelPickerTabs.js';
 import { ModelPickerWelcome } from './modelPickerWelcome.js';
+import { HYDRA_FUSION_LEARN_MORE_URL, createMessageBanner } from './modelPickerHover.js';
 
 const OTHER_MODELS_SECTION = "other";
 const PICKER_WIDTH = 320;
 const PRICING_EXPANDED_STORAGE_KEY = "chat.modelPicker.pricingExpanded";
+const MODEL_DETAILS_ACTION_ID = "chat.modelPicker.details";
 let TabbedModelPicker = class TabbedModelPicker extends Disposable {
     get isVisible() {
         return this._widget.isVisible;
@@ -36,17 +53,21 @@ let TabbedModelPicker = class TabbedModelPicker extends Disposable {
         _entitlementService,
         _languageModelsService,
         _openerService,
-        _storageService
+        _storageService,
+        _configurationService,
+        _contextViewService
     ) {
         super();
         this._entitlementService = _entitlementService;
         this._languageModelsService = _languageModelsService;
         this._openerService = _openerService;
         this._storageService = _storageService;
+        this._configurationService = _configurationService;
+        this._contextViewService = _contextViewService;
         this._onDidHide = this._register(( new Emitter()));
         this.onDidHide = this._onDidHide.event;
         this._cards = this._register(( new DisposableMap()));
-        this._autoRow = this._register(( new MutableDisposable()));
+        this._configurationListener = this._register(( new MutableDisposable()));
         this._onDidChangePricingDisclosure = this._register(( new Emitter()));
         this._pricingDisclosure = {
             isExpanded: () => this._storageService.getBoolean(PRICING_EXPANDED_STORAGE_KEY, StorageScope.APPLICATION, false),
@@ -62,15 +83,41 @@ let TabbedModelPicker = class TabbedModelPicker extends Disposable {
             onDidChange: this._onDidChangePricingDisclosure.event
         };
         this._searchVisible = false;
+        this._filterValue = "";
         this._speedVariants = ( new Map());
         this._preferredSpeedVariants = ( new Map());
         this._selectionVersion = 0;
+        this._models = [];
         this._widget = this._register(instantiationService.createInstance(TabbedActionListWidget));
         this._register(this._widget.onDidChangeTab(id => {
             this._activeDestination = id;
         }));
+        this._register(this._configurationService.onDidChangeConfiguration(e => {
+            if (e.affectsConfiguration(ChatConfiguration.DefaultModel)) {
+                this.refresh();
+            }
+        }));
+        this._register(this._entitlementService.onDidChangeEntitlement(() => {
+            if (!this.isVisible || !this._context) {
+                return;
+            }
+            this._context = this._refreshContextForModels(this._context, this._models);
+            if (this._context.selectedModelId && !( this._context.models.some(model => model.identifier === this._context?.selectedModelId))) {
+                const fallback = this._autoModel(this._context) ?? this._fallbackModel(this._context);
+                if (fallback) {
+                    this._applyModelSelection(fallback, this._context, false);
+                }
+            }
+            this.refresh();
+        }));
         this._register(this._widget.onDidHide(() => {
+            this._context?.workflow?.cancel();
             this._searchVisible = false;
+            this._filterValue = "";
+            this._selectionVersion++;
+            this._detailsModelId = undefined;
+            this._detailsCard = undefined;
+            this._configurationListener.clear();
             this._cards.clearAndDisposeAll();
             this._onDidHide.fire();
         }));
@@ -78,25 +125,127 @@ let TabbedModelPicker = class TabbedModelPicker extends Disposable {
     hide() {
         this._widget.hide();
     }
-    show(anchor, context) {
+    dispose() {
+        this.hide();
+        super.dispose();
+    }
+    openWithFilter(options) {
+        this._searchVisible = true;
+        this._showCurrent(options.initialFilterValue, options.initialFocusItemId);
+    }
+    show(
+        anchor,
+        context,
+        detailsModelId,
+        focusConfiguration = false,
+        contextViewLayer,
+        options
+    ) {
         if (!this._widget.isVisible) {
             this._activeDestination = undefined;
+            if (context.workflow?.available.get() && context.workflow.summary.get()) {
+                context.workflow.start();
+            }
         }
         this._anchor = anchor;
-        this._context = context;
-        if (context.selectedModelId && !this._isAutoSelected(context)) {
-            this._lastExplicitModelId = context.selectedModelId;
+        this._selectionVersion++;
+        this._models = context.models;
+        const pickerContext = this._filterModelsForEntitlement(context);
+        this._context = pickerContext;
+        this._rememberHydraFusionTier(pickerContext);
+        this._configurationListener.value = context.configurationAccess.onDidChange?.(() => this.refresh());
+        this._contextViewLayer = contextViewLayer;
+        if (options?.initialFilterValue !== undefined) {
+            this._searchVisible = true;
+        }
+        this._showCurrent(options?.initialFilterValue, options?.initialFocusItemId);
+        const requestedModel = pickerContext.models.find(model => model.identifier === detailsModelId);
+        const detailsModel = requestedModel && this._getDetailsModel(requestedModel, pickerContext);
+        if (detailsModel) {
+            this._showModelDetails(detailsModel, focusConfiguration);
+        }
+    }
+    setSelectedModel(modelId) {
+        if (this._context && this._context.selectedModelId !== modelId) {
+            this._selectionVersion++;
+            this._context = {
+                ...this._context,
+                selectedModelId: modelId
+            };
+            this._rememberHydraFusionTier(this._context);
+            this.refresh();
+        }
+    }
+    refresh(models) {
+        if (!this.isVisible || !this._context) {
+            return;
+        }
+        if (models) {
+            this._models = models;
+            this._context = this._refreshContextForModels(this._context, this._models);
         }
-        this._showCurrent();
+        const destinations = this._buildDestinations(this._context);
+        if (!destinations.length) {
+            this.hide();
+            return;
+        }
+        if (models) {
+            this._speedVariants.clear();
+            for (const destination of destinations) {
+                this._buildSections(destination, this._context);
+            }
+        }
+        const model = this._context.models.find(model => model.identifier === this._detailsModelId);
+        if (this._detailsModelId && !model) {
+            this._widget.refreshActiveList();
+            this._widget.hideDetails();
+            return;
+        } else if (model) {
+            this._getModelCard(model, this._context).refresh();
+        }
+        this._widget.refreshActiveList();
     }
-    _showCurrent(initialFilterValue) {
+    _filterModelsForEntitlement(context) {
+        return {
+            ...context,
+            models: filterModelPickerModelsForEntitlement(
+                context.models,
+                this._entitlementService.entitlement,
+                this._languageModelsService
+            ),
+            controlModels: filterModelPickerControlModelsForEntitlement(
+                context.controlModels,
+                context.models,
+                this._entitlementService.entitlement,
+                this._languageModelsService
+            )
+        };
+    }
+    _refreshContextForModels(context, models) {
+        const controlModels = getModelPickerControlModels(
+            this._languageModelsService.getModelsControlManifest(),
+            this._entitlementService.entitlement,
+            models
+        );
+        return this._filterModelsForEntitlement({
+            ...context,
+            models,
+            controlModels
+        });
+    }
+    _showCurrent(initialFilterValue, initialFocusItemId) {
         const context = this._context;
         const anchor = this._anchor;
         if (!context || !anchor) {
             return;
         }
+        this._filterValue = this._searchVisible ? initialFilterValue ?? "" : "";
         this._speedVariants.clear();
+        this._detailsModelId = undefined;
+        this._detailsCard = undefined;
         this._cards.clearAndDisposeAll();
+        const workflow = context.workflow?.available.get() ? context.workflow : undefined;
+        const step = workflow?.state.get();
         const destinations = this._buildDestinations(context);
         if (!destinations.length) {
             return;
@@ -104,7 +253,6 @@ let TabbedModelPicker = class TabbedModelPicker extends Disposable {
         if (!this._activeDestination || !( destinations.some(destination => destination.id === this._activeDestination))) {
             this._activeDestination = this._destinationForSelectedModel(destinations, context) ?? destinations[0].id;
         }
-        const autoModel = context.models.find(isAutoModel);
         this._widget.show({
             user: "ChatTabbedModelPicker",
             anchor,
@@ -115,13 +263,13 @@ let TabbedModelPicker = class TabbedModelPicker extends Disposable {
                 tooltip: destination.label
             })),
             initialTab: this._activeDestination,
-            sizingTab: MODEL_PICKER_BUILT_IN_DESTINATION,
-            showCheckedItemHover: !this._isAutoSelected(context),
+            sizingTab: this._hasBuiltInChoices(context) ? MODEL_PICKER_BUILT_IN_DESTINATION : undefined,
+            contextViewLayer: this._contextViewLayer,
             tabBarActions: this._buildTabBarActions(context),
             tabBarClassName: "chat-model-picker-tabbar",
             widgetClassNames: () => [
                 "chat-model-picker-widget",
-                ...(this._isAutoSelected(this._context ?? context) ? ["auto-enabled"] : []),
+                ...(step ? ["model-picker-workflow"] : []),
                 ...(this._searchVisible ? ["search-mode"] : [])
             ],
             tabLabels: "active",
@@ -138,37 +286,61 @@ let TabbedModelPicker = class TabbedModelPicker extends Disposable {
                     candidate === destination ? sections : this._buildSections(candidate, current),
                     current
                 )) : this._buildItems(destination, sections, current);
+                const hint = step ? {
+                    text: `${step.title}\n${step.description}`,
+                    link: undefined,
+                    dismiss: undefined
+                } : current.cacheBreakHint ?? current.configurationCacheBreakHint;
+                const baseListOptions = withActionWidgetDropdownMotion({
+                    className: "chat-model-picker-dropdown chat-model-picker-tabbed",
+                    stopToolbarPointerPropagation: true,
+                    tabThroughItemActions: true,
+                    detailItemHeight: 64,
+                    showFilter: searching,
+                    filterPlaceholder: ( localize(14576, "Search models")),
+                    focusFilterOnOpen: searching,
+                    initialFilterValue,
+                    initialFocusItemId,
+                    filterAsCombobox: true,
+                    onType: text => {
+                        this._searchVisible = true;
+                        current.onDidSearch();
+                        this._showCurrent(text);
+                    },
+                    onDidChangeFilter: text => {
+                        this._filterValue = text;
+                        current.onDidSearch();
+                    },
+                    headerText: hint?.text,
+                    headerIcon: hint ? Codicon.info : undefined,
+                    headerLink: hint?.link,
+                    headerDismiss: hint?.dismiss,
+                    collapsedByDefault: !step && hasPromotedModels(sections) ? ( new Set([OTHER_MODELS_SECTION])) : undefined,
+                    onDidToggleSection: (section, collapsed) => {
+                        if (section === OTHER_MODELS_SECTION) {
+                            current.onDidToggleOtherModels(collapsed);
+                        }
+                    },
+                    linkHandler: uri => current.onUnavailableLinkClick(uri),
+                    maxWidth: PICKER_WIDTH,
+                    hideDefaultKeybindingTooltip: true,
+                    reserveSubmenuSpace: false
+                });
+                const listOptions = anchor.closest(".monaco-dialog-box") ? {
+                    ...baseListOptions,
+                    anchorPosition: AnchorPosition.BELOW
+                } : {
+                    ...baseListOptions,
+                    preferredAnchorPosition: AnchorPosition.ABOVE
+                };
                 return {
-                    items,
-                    listOptions: withChatInputPickerMotion({
-                        className: "chat-model-picker-dropdown chat-model-picker-tabbed",
-                        persistentHover: true,
-                        showFilter: searching,
-                        filterPlaceholder: ( localize(12242, "Search models")),
-                        focusFilterOnOpen: searching,
-                        initialFilterValue,
-                        filterAsCombobox: true,
-                        onType: text => {
-                            this._searchVisible = true;
-                            this._showCurrent(text);
-                        },
-                        headerText: current.cacheBreakHint?.text,
-                        headerIcon: current.cacheBreakHint ? Codicon.info : undefined,
-                        headerLink: current.cacheBreakHint?.link,
-                        headerDismiss: current.cacheBreakHint?.dismiss,
-                        collapsedByDefault: hasPromotedModels(sections) ? ( new Set([OTHER_MODELS_SECTION])) : undefined,
-                        onDidToggleSection: (section, collapsed) => {
-                            if (section === OTHER_MODELS_SECTION) {
-                                current.onDidToggleOtherModels(collapsed);
-                            }
-                        },
-                        linkHandler: uri => current.onUnavailableLinkClick(uri),
-                        maxWidth: PICKER_WIDTH,
-                        hideDefaultKeybindingTooltip: true,
-                        reserveSubmenuSpace: false
-                    })
+                    items: step ? items.filter(item => !item.item || !( current.models.some(
+                        model => model.identifier === item.item?.id && (isAutoModel(model) || isHydraFusionModel(model))
+                    ))) : items,
+                    listOptions
                 };
             },
+            renderFooter: workflow && step ? container => this._renderWorkflowFooter(container, workflow) : undefined,
             renderEmpty: (container, activeTab) => {
                 const destination = destinations.find(candidate => candidate.id === activeTab);
                 if (!destination?.placeholders.length) {
@@ -178,22 +350,64 @@ let TabbedModelPicker = class TabbedModelPicker extends Disposable {
                 container.appendChild(welcome.element);
                 return welcome;
             },
-            renderFooter: autoModel ? container => this._renderAutoRow(container, autoModel, context) : undefined,
+            openItemDetails: item => this._openItemDetails(item),
             delegate: {
                 onSelect: action => {
                     void action.run();
-                    this._widget.hide();
+                    if (!step) {
+                        this._widget.hide();
+                    }
                 },
                 onHide: () => {}
             },
-            accessibilityProvider: getModelPickerAccessibilityProvider(this._searchVisible)
+            accessibilityProvider: getModelPickerAccessibilityProvider(this._searchVisible, step?.multiple ?? false)
         });
         if (this._context?.selectedModelId) {
             this._rememberSpeedVariant(this._context.selectedModelId);
         }
     }
     _buildDestinations(context) {
-        return buildModelPickerDestinations(context.models, this._languageModelsService, context.providerPlaceholders);
+        const autoModel = this._autoModel(context);
+        const hydraFusionModels = this._hydraFusionModels(context);
+        const ensembleHydraFusion = model => !!autoModel?.metadata.autoModelEnsemble && isHydraFusionModel(model) && !isUserProvidedModel(model, this._languageModelsService);
+        return buildModelPickerDestinations(
+            context.models,
+            this._languageModelsService,
+            context.providerPlaceholders,
+            model => model === autoModel || hydraFusionModels.includes(model) || ensembleHydraFusion(model),
+            this._hasBuiltInUpsells(context)
+        );
+    }
+    _hasBuiltInUpsells(context) {
+        const entitlement = this._entitlementService.entitlement;
+        return (entitlement === ChatEntitlement.Free || entitlement === ChatEntitlement.EDU) && this._buildSections({
+            id: MODEL_PICKER_BUILT_IN_DESTINATION,
+            models: []
+        }, context).unavailable.length > 0;
+    }
+    _hasBuiltInChoices(context) {
+        return !!(this._autoModel(context) || this._hydraFusionModels(context).length || this._fallbackModel(context));
+    }
+    _autoModel(context) {
+        return context.models.find(
+            model => isAutoModel(model) && !isUserProvidedModel(model, this._languageModelsService) && !requiresNewerVSCode(
+                model,
+                context.controlModels,
+                context.unavailableContext.currentVSCodeVersion
+            )
+        );
+    }
+    _hydraFusionModels(context) {
+        const ensemble = this._autoModel(context)?.metadata.autoModelEnsemble;
+        return [...( COPILOT_HYDRA_FUSION_MODEL_NAMES.keys())].filter(
+            id => id !== COPILOT_HYDRA_FUSION_MODEL_ID || !ensemble || ensemble.intelligenceUsesHydraFusion
+        ).map(id => context.models.find(
+            model => model.metadata.id === id && isHydraFusionModel(model) && !isUserProvidedModel(model, this._languageModelsService) && !requiresNewerVSCode(
+                model,
+                context.controlModels,
+                context.unavailableContext.currentVSCodeVersion
+            )
+        )).filter(model => !!model);
     }
     _rememberSpeedVariant(modelIdentifier) {
         const pair = this._speedVariants.get(modelIdentifier);
@@ -207,11 +421,46 @@ let TabbedModelPicker = class TabbedModelPicker extends Disposable {
             id => id === modelIdentifier || id === pair?.standard.identifier || id === pair?.fast.identifier
         );
     }
-    _isAutoSelected(context) {
-        const selected = context.models.find(model => model.identifier === context.selectedModelId);
-        return !!selected && isAutoModel(selected);
+    _hostsHydraFusion(context) {
+        const auto = this._autoModel(context);
+        return !!auto?.metadata.autoModelEnsemble && this._hydraFusionModels(context).length > 0 && !!getModelConfigProperty(auto, context.configurationAccess, MODEL_CONFIG_GROUP_EFFORT);
+    }
+    _hydraFusionTiers(context) {
+        if (this._autoModel(context)?.metadata.autoModelEnsemble) {
+            return [];
+        }
+        const models = this._hydraFusionModels(context);
+        return models.length > 1 ? models : [];
+    }
+    _hydraFusionRowModel(tiers, context) {
+        const organizationDefault = this._getOrganizationDefaultModel(context);
+        return tiers.find(model => model.identifier === context.selectedModelId) ?? tiers.find(model => model.identifier === this._preferredHydraFusionTier) ?? tiers.find(model => model.identifier === organizationDefault?.identifier) ?? tiers[0];
+    }
+    _selectedHydraFusionTier(context) {
+        return context.selectedModelId && this._hostsHydraFusion(context) ? this._hydraFusionModels(context).find(model => model.identifier === context.selectedModelId) : undefined;
+    }
+    _getHydraFusionTier(hydraFusion, context) {
+        const label = getEnsembleTierLabel(this._autoModel(context)?.metadata, hydraFusion.metadata.id);
+        if (!label) {
+            return {
+                label: hydraFusion.metadata.name
+            };
+        }
+        return {
+            label,
+            replacesTier: hydraFusion.metadata.id === COPILOT_HYDRA_FUSION_MODEL_ID ? "intelligence" : undefined
+        };
+    }
+    _getDetailsModel(model, context) {
+        if (!isHydraFusionModel(model) || this._hydraFusionTiers(context).includes(model)) {
+            return model;
+        }
+        return this._hydraFusionModels(context).includes(model) && this._hostsHydraFusion(context) ? this._autoModel(context) : undefined;
     }
     _destinationForSelectedModel(destinations, context) {
+        if (context.selectedModelId === this._autoModel(context)?.identifier || ( this._hydraFusionModels(context).some(model => model.identifier === context.selectedModelId))) {
+            return MODEL_PICKER_BUILT_IN_DESTINATION;
+        }
         return destinations.find(destination => ( destination.models.some(model => model.identifier === context.selectedModelId)))?.id;
     }
     _buildSections(destination, context) {
@@ -219,11 +468,13 @@ let TabbedModelPicker = class TabbedModelPicker extends Disposable {
         const sections = buildModelPickerSections({
             models: destination.models,
             selectedModelId: context.selectedModelId,
+            organizationDefaultModelId: this._getOrganizationDefaultModel(context)?.identifier,
             pinnedModelIds: context.pinnedModelIds,
             controlModels: context.controlModels,
             preferredSpeedVariants: this._preferredSpeedVariants,
             showSuggested: isBuiltIn,
             showUnavailable: isBuiltIn && context.unavailableContext.show,
+            alwaysShowUnavailableModelIds: isBuiltIn && isHydraFusionUpgradeOnly(this._entitlementService.entitlement) ? ( new Set([COPILOT_HYDRA_FUSION_MODEL_ID])) : undefined,
             currentVSCodeVersion: context.unavailableContext.currentVSCodeVersion
         });
         for (const [id, pair] of sections.speedVariants) {
@@ -231,37 +482,129 @@ let TabbedModelPicker = class TabbedModelPicker extends Disposable {
         }
         return sections;
     }
+    _getOrganizationDefaultModel(context) {
+        const configuredDefault = this._configurationService.inspect(ChatConfiguration.DefaultModel).policyValue?.trim();
+        return resolveConfiguredModel(configuredDefault, context.models);
+    }
+    _getOrganizationDefaultForModel(model, context) {
+        const defaultModel = this._getOrganizationDefaultModel(context);
+        const variants = this._speedVariants.get(model.identifier);
+        const hydraFusionTiers = this._hydraFusionTiers(context);
+        return defaultModel && (defaultModel.identifier === model.identifier || defaultModel.identifier === variants?.standard.identifier || defaultModel.identifier === variants?.fast.identifier || (hydraFusionTiers.includes(model) && hydraFusionTiers.includes(defaultModel))) ? defaultModel : undefined;
+    }
     _buildTabBarActions(context) {
         const actions = [];
+        const workflow = context.workflow;
+        if (workflow?.available.get()) {
+            actions.push({
+                id: "workflow",
+                icon: Codicon.layers,
+                tooltip: workflow.label,
+                checked: !!workflow.state.get(),
+                run: () => {
+                    if (workflow.state.get()) {
+                        workflow.cancel();
+                    } else {
+                        workflow.start();
+                    }
+                    this._showCurrent();
+                }
+            });
+        }
         if (context.showManageModels && !this._searchVisible) {
             actions.push({
                 id: "addProvider",
                 icon: Codicon.add,
-                tooltip: ( localize(12243, "Add Models...")),
+                tooltip: ( localize(14577, "Add Models...")),
                 run: () => {
                     this._widget.hide();
                     context.onManageModels();
                 }
             });
         }
-        actions.push({
-            id: "search",
-            icon: Codicon.search,
-            tooltip: ( localize(12244, "Search Models")),
-            alignEnd: true,
-            checked: this._searchVisible,
-            run: () => {
-                this._searchVisible = !this._searchVisible;
+        if (context.models.length) {
+            actions.push({
+                id: "search",
+                icon: Codicon.search,
+                tooltip: ( localize(14578, "Search Models")),
+                alignEnd: true,
+                checked: this._searchVisible,
+                run: () => {
+                    this._searchVisible = !this._searchVisible;
+                    if (this._searchVisible) {
+                        context.onDidSearch();
+                    }
+                    this._showCurrent();
+                }
+            });
+        }
+        return actions;
+    }
+    _renderWorkflowFooter(container, workflow) {
+        const store = ( new DisposableStore());
+        const step = workflow.state.get();
+        container.classList.add("model-picker-workflow-footer");
+        if (step.count) {
+            const count = step.count;
+            const row = append(container, $(".model-picker-workflow-count"));
+            append(row, $("span")).textContent = count.label;
+            const select = store.add(( new SelectBox(Array.from({
+                length: count.max - count.min + 1
+            }, (_, index) => ({
+                text: String(index + count.min)
+            })), count.value - count.min, this._contextViewService, defaultSelectBoxStyles, {
+                ariaLabel: count.label,
+                contextViewLayer: (this._contextViewLayer ?? 0) + 1
+            })));
+            select.render(row);
+            store.add(select.onDidSelect(event => workflow.setCount(event.index + count.min)));
+        }
+        const actions = append(container, $(".model-picker-workflow-actions"));
+        const cancel = store.add(( new Button(actions, {
+            ...defaultButtonStyles,
+            secondary: true
+        })));
+        cancel.label = ( localize(14579, "Cancel"));
+        store.add(cancel.onDidClick(() => this._widget.hide()));
+        if (step.canGoBack) {
+            const back = store.add(( new Button(actions, {
+                ...defaultButtonStyles,
+                secondary: true,
+                supportIcons: true
+            })));
+            back.label = ( localize(14580, "{0} Back", "$(arrow-left)"));
+            store.add(back.onDidClick(() => {
+                workflow.back();
+                this._searchVisible = false;
+                this._showCurrent();
+                status(workflow.state.get().title);
+            }));
+        }
+        const next = store.add(( new Button(actions, {
+            ...defaultButtonStyles,
+            supportIcons: true
+        })));
+        next.label = step.canFinish ? ( localize(14581, "Done")) : ( localize(14582, "Next {0}", "$(arrow-right)"));
+        next.enabled = step.canFinish || step.canGoNext;
+        store.add(next.onDidClick(() => {
+            if (step.canFinish) {
+                workflow.finish();
+                this._widget.hide();
+            } else {
+                workflow.next();
+                this._searchVisible = false;
                 this._showCurrent();
+                status(workflow.state.get().title);
             }
-        });
-        return actions;
+        }));
+        return store;
     }
     _buildItems(destination, sections, context) {
-        if (!destination.models.length && !sections.unavailable.length) {
+        const isBuiltIn = destination.id === MODEL_PICKER_BUILT_IN_DESTINATION;
+        const items = isBuiltIn && !context.workflow?.state.get() ? this._buildRoutingItems(context) : [];
+        if (!items.length && !destination.models.length && !sections.unavailable.length) {
             return [];
         }
-        const items = [];
         const appendSection = (label, models, unavailable = []) => {
             if (!models.length && !unavailable.length) {
                 return;
@@ -275,32 +618,33 @@ let TabbedModelPicker = class TabbedModelPicker extends Disposable {
             for (const model of models) {
                 items.push(this._createModelItem(model, context, undefined));
             }
-            for (const {
-                id,
-                entry,
-                needsUpdate
-            } of unavailable) {
+            for (const unavailableEntry of unavailable) {
                 const {
                     unavailableContext
                 } = context;
-                const reason = needsUpdate ? "update" : getUnavailableReason(entry, this._entitlementService, unavailableContext.currentVSCodeVersion);
                 items.push(createUnavailableModelItem(
-                    id,
-                    entry,
-                    reason,
+                    unavailableEntry.id,
+                    unavailableEntry.entry,
+                    this._getUnavailableReason(unavailableEntry, context),
                     unavailableContext.manageSettingsUrl,
                     unavailableContext.updateStateType,
                     this._entitlementService
                 ));
             }
         };
-        appendSection(( localize(12245, "Pinned")), sections.pinned);
-        appendSection(undefined, sections.suggested, sections.unavailable);
+        appendSection(( localize(14583, "Pinned")), sections.pinned);
+        const upsellLabel = isBuiltIn && !this._fallbackModel(context) ? this._getUpsellSectionLabel(sections.unavailable, context) : undefined;
+        if (upsellLabel) {
+            appendSection(undefined, sections.suggested);
+            appendSection(upsellLabel, [], sections.unavailable);
+        } else {
+            appendSection(undefined, sections.suggested, sections.unavailable);
+        }
         if (sections.other.length) {
             const collapsible = hasPromotedModels(sections);
             const section = collapsible ? OTHER_MODELS_SECTION : undefined;
             if (collapsible) {
-                const label = ( localize(12246, "Other Models"));
+                const label = ( localize(14584, "Other Models"));
                 const count = sections.other.length;
                 items.push({
                     item: {
@@ -314,7 +658,7 @@ let TabbedModelPicker = class TabbedModelPicker extends Disposable {
                     },
                     kind: ActionListItemKind.Action,
                     label,
-                    ariaDescription: ( localize(12247, "{0} more models", count)),
+                    ariaDescription: ( localize(14585, "{0} more models", count)),
                     group: {
                         title: "",
                         icon: Codicon.chevronDown
@@ -332,100 +676,328 @@ let TabbedModelPicker = class TabbedModelPicker extends Disposable {
         return items;
     }
     _buildSearchItems(destination, sections, context) {
-        return [...sections.pinned, ...sections.suggested, ...sections.other].sort((left, right) => left.metadata.name.localeCompare(right.metadata.name)).map(model => this._createModelItem(
+        const routingModels = destination.id === MODEL_PICKER_BUILT_IN_DESTINATION ? [this._autoModel(context), ...this._hydraFusionRowModels(context)].filter(model => !!model) : [];
+        return [
+            ...sections.pinned,
+            ...sections.suggested,
+            ...sections.other,
+            ...routingModels
+        ].sort(
+            (left, right) => this._getRowLabel(left, context).localeCompare(this._getRowLabel(right, context))
+        ).map(model => this._createModelItem(
             model,
             context,
             undefined,
             getModelProviderLabel(model, this._languageModelsService)
         ));
     }
+    _hydraFusionRowModels(context) {
+        const tiers = this._hydraFusionTiers(context);
+        return tiers.length ? [this._hydraFusionRowModel(tiers, context)] : this._hydraFusionModels(context);
+    }
+    _getRowLabel(model, context) {
+        const tiers = this._hydraFusionTiers(context);
+        return tiers.includes(model) ? tiers[0].metadata.name : model.metadata.name;
+    }
+    _buildRoutingItems(context) {
+        const items = [];
+        const auto = this._autoModel(context);
+        if (auto) {
+            items.push(this._createModelItem(auto, context));
+        }
+        if (this._hostsHydraFusion(context)) {
+            return items;
+        }
+        for (const hydra of this._hydraFusionRowModels(context)) {
+            items.push(this._createModelItem(hydra, context));
+        }
+        return items;
+    }
+    _getUnavailableReason(
+        {
+            entry,
+            needsUpdate
+        },
+        context
+    ) {
+        return needsUpdate ? "update" : getUnavailableReason(
+            entry,
+            this._entitlementService,
+            context.unavailableContext.currentVSCodeVersion
+        );
+    }
+    _getUpsellSectionLabel(unavailable, context) {
+        return unavailable.length && unavailable.every(entry => this._getUnavailableReason(entry, context) === "upgrade") ? ( localize(14586, "Upgrade for More Models")) : undefined;
+    }
+    _getOrganizationDefaultBadges(model, context) {
+        const defaultModel = this._getOrganizationDefaultForModel(model, context);
+        return defaultModel ? [{
+            label: organizationDefaultLabel,
+            className: "chat-model-picker-org-default-badge",
+            tooltip: getOrganizationDefaultDescription(defaultModel.metadata.name)
+        }] : undefined;
+    }
     _createModelItem(model, context, section, providerLabel) {
+        const workflow = context.workflow;
+        const step = workflow?.state.get();
+        if (workflow && step) {
+            const checked = step.selectedModelIds.includes(model.identifier);
+            const disabled = step.multiple && !checked && step.selectedModelIds.length >= step.maxSelections;
+            const {
+                action,
+                ariaDescription
+            } = createModelAction(model, undefined, () => {
+                workflow.select(model.identifier);
+                this._showCurrent(this._filterValue, model.identifier);
+            }, section);
+            return {
+                item: {
+                    ...action,
+                    checked,
+                    enabled: !disabled
+                },
+                kind: ActionListItemKind.Action,
+                label: action.label,
+                ariaDescription,
+                group: {
+                    title: "",
+                    icon: checked ? Codicon.check : Codicon.blank
+                },
+                hideIcon: false,
+                section,
+                disabled,
+                className: "chat-model-picker-model"
+            };
+        }
+        const hydraFusionTier = isAutoModel(model) ? this._selectedHydraFusionTier(context) : undefined;
         const {
             action,
             ariaDescription
-        } = createModelAction(model, context.selectedModelId, next => {
-            this._selectionVersion++;
-            const pair = this._speedVariants.get(next.identifier);
-            context.onSelect(pair ? getPreferredSpeedVariant(
-                pair,
-                this._context?.selectedModelId,
-                this._preferredSpeedVariants.get(pair.standard.identifier)
-            ) : next);
-        }, section, true);
-        const badge = getModelBadge(model, {
-            configurationAccess: context.configurationAccess,
+        } = createModelAction(
+            model,
+            hydraFusionTier ? model.identifier : context.selectedModelId,
+            next => {
+                this._selectionVersion++;
+                if (isAutoModel(next) && this._selectedHydraFusionTier(this._context ?? context)) {
+                    return;
+                }
+                const pair = this._speedVariants.get(next.identifier);
+                const selected = pair ? getPreferredSpeedVariant(
+                    pair,
+                    this._context?.selectedModelId,
+                    this._preferredSpeedVariants.get(pair.standard.identifier)
+                ) : next;
+                this._applyModelSelection(selected, this._context ?? context);
+            },
+            section);
+        const routingModel = isAutoModel(model) || isHydraFusionModel(model);
+        const modelBadge = getModelBadge(model, {
             providerLabel
         });
-        const autoEnabled = this._isAutoSelected(context);
+        const routingBadge = !modelBadge && routingModel ? (hydraFusionTier ?? model).metadata.detail : undefined;
+        const badgeClassName = modelBadge ? `chat-model-picker-badge-${modelBadge.tone}` : routingBadge ? "chat-model-picker-badge-preview" : undefined;
+        const hydraFusionTierLabel = hydraFusionTier && this._getHydraFusionTier(hydraFusionTier, context).label;
+        const ownTierLabel = this._hydraFusionTiers(context).includes(model) ? getHydraFusionTierLabel(model.metadata.id) : undefined;
+        const tierLabel = hydraFusionTierLabel ?? ownTierLabel;
+        const rowLabel = this._getRowLabel(model, context);
+        const summary = tierLabel ?? getModelConfigSummary(model, context.configurationAccess);
+        const configDescription = hydraFusionTierLabel ? ( localize(
+            14587,
+            "{0}: {1}",
+            getModelConfigProperty(model, context.configurationAccess, MODEL_CONFIG_GROUP_EFFORT)?.schema.title ?? ( localize(14588, "Optimize for")),
+            hydraFusionTierLabel
+        )) : ownTierLabel ? ( localize(14589, "Tier: {0}", ownTierLabel)) : getModelConfigDescription(model, context.configurationAccess);
+        const defaultModel = this._getOrganizationDefaultForModel(model, context);
+        const defaultDescription = defaultModel && getOrganizationDefaultDescription(defaultModel.metadata.name);
+        const hasDetails = !isHydraFusionModel(model) || !!ownTierLabel;
+        return {
+            item: rowLabel === action.label ? action : {
+                ...action,
+                label: rowLabel,
+                tooltip: rowLabel
+            },
+            kind: ActionListItemKind.Action,
+            label: rowLabel,
+            description: modelBadge || routingBadge ? undefined : action.description,
+            badge: modelBadge?.text ?? routingBadge,
+            additionalBadges: this._getOrganizationDefaultBadges(model, context),
+            ariaDescription: [ariaDescription, configDescription].filter(Boolean).join(", "),
+            opensDialog: hasDetails,
+            group: {
+                title: "",
+                icon: action.icon ?? ThemeIcon.fromId(action.checked ? Codicon.check.id : Codicon.blank.id)
+            },
+            hideIcon: false,
+            section,
+            className: [
+                "chat-model-picker-model",
+                ...(action.checked ? ["chat-model-picker-current"] : []),
+                ...(badgeClassName ? [badgeClassName] : [])
+            ].join(" "),
+            toolbarLabels: true,
+            toolbarActions: hasDetails ? [this._createDetailsAction(model, rowLabel, summary)] : undefined,
+            toolbarDialogActionIds: [MODEL_DETAILS_ACTION_ID],
+            tooltip: [rowLabel, summary, defaultDescription].filter(Boolean).join(" · ")
+        };
+    }
+    _createDetailsAction(model, name, summary) {
+        return toAction({
+            id: MODEL_DETAILS_ACTION_ID,
+            label: summary ?? ( localize(14590, "Details")),
+            tooltip: summary ? ( localize(14591, "{0} Details, {1}", name, summary)) : ( localize(14592, "{0} Details", name)),
+            run: () => this._showModelDetails(model, true)
+        });
+    }
+    _openItemDetails(item) {
+        const model = item.toolbarActions?.some(action => action.id === MODEL_DETAILS_ACTION_ID) ? this._context?.models.find(candidate => candidate.identifier === item.item?.id) : undefined;
+        if (!model) {
+            return false;
+        }
+        this._showModelDetails(model, true, true);
+        return true;
+    }
+    _getModelCard(model, context) {
         let selectionVersion = this._selectionVersion;
+        const routingModel = isAutoModel(model) || isHydraFusionModel(model);
+        const hydraFusionModels = isAutoModel(model) && this._hostsHydraFusion(context) ? this._hydraFusionModels(context) : [];
+        const hydraFusionTiers = this._hydraFusionTiers(context);
+        const ownTiers = hydraFusionTiers.includes(model) ? hydraFusionTiers : [];
         const cardOptions = {
             model,
+            name: ownTiers.length ? this._getRowLabel(model, context) : undefined,
+            description: ownTiers[0]?.metadata.tooltip,
             configurationAccess: context.configurationAccess,
             isUBB: context.isUBB,
             openerService: this._openerService,
             isPinned: this._pinnedVariantIds(model.identifier, context).length > 0,
+            organizationDefaultModel: this._getOrganizationDefaultForModel(model, context),
+            externalHeader: true,
             pricingDisclosure: this._pricingDisclosure,
             speedVariants: this._speedVariants.get(model.identifier),
+            modelChoices: ownTiers.length ? {
+                ariaLabel: ( localize(14593, "HydraFusion tier")),
+                choices: ownTiers.map(tier => ({
+                    label: getHydraFusionTierLabel(tier.metadata.id),
+                    model: tier
+                }))
+            } : undefined,
+            routingAlternatives: hydraFusionModels.map(hydraFusion => {
+                const tier = this._getHydraFusionTier(hydraFusion, context);
+                return {
+                    model: hydraFusion,
+                    label: tier.label,
+                    replacesTier: tier.replacesTier,
+                    description: hydraFusion.metadata.id === COPILOT_HYDRA_FUSION_MAX_MODEL_ID ? ( localize(
+                        14594,
+                        "Max uses multiple models on every task for the most thorough results."
+                    )) : ( localize(14595, "High picks a workflow per task, using one or more models.")),
+                    learnMoreUrl: HYDRA_FUSION_LEARN_MORE_URL,
+                    selected: context.selectedModelId === hydraFusion.identifier
+                };
+            }),
             onWillSelect: () => {
                 selectionVersion = ++this._selectionVersion;
             },
             onSelect: next => {
                 if (selectionVersion === this._selectionVersion && this._widget.isVisible && next.identifier !== (this._context ?? context).selectedModelId) {
                     this._rememberSpeedVariant(next.identifier);
-                    context.onSelect(next);
-                    this._context = {
-                        ...(this._context ?? context),
-                        selectedModelId: next.identifier
-                    };
-                    this._lastExplicitModelId = next.identifier;
+                    if (!hydraFusionModels.includes(next)) {
+                        this._detailsModelId = next.identifier;
+                    }
+                    this._applyModelSelection(next, this._context ?? context);
                 }
             },
             onDidAccept: () => {
-                this._widget.refreshActiveList({
-                    focusItemId: selectionVersion === this._selectionVersion ? this._context?.selectedModelId : undefined,
-                    preserveHover: true
-                });
+                this.refresh();
             },
-            onTogglePin: context.onTogglePin ? pinned => this._togglePin(model.identifier, pinned) : undefined,
-            onDidChangeConfiguration: (group, key, fromValue, toValue) => {
-                context.onConfigurationChanged(model, group, key, fromValue, toValue);
-            }
-        };
-        const createCard = () => {
-            const key = this._speedVariants.get(model.identifier)?.standard.identifier ?? model.identifier;
-            let card = this._cards.get(key);
-            if (card) {
-                card.update(cardOptions);
-            } else {
-                card = ( new ModelCard(cardOptions));
-                this._cards.set(key, card);
+            onTogglePin: context.onTogglePin && !routingModel ? pinned => this._togglePin(model.identifier, pinned) : undefined,
+            onDidChangeConfiguration: (...change) => {
+                context.onConfigurationChanged(model, ...change);
             }
-            return card.element;
         };
-        return {
-            item: action,
-            kind: ActionListItemKind.Action,
-            label: action.label,
-            description: badge ? undefined : action.description,
-            badge: badge?.text,
-            ariaDescription,
-            group: {
-                title: "",
-                icon: action.icon ?? ThemeIcon.fromId(action.checked ? Codicon.check.id : Codicon.blank.id)
+        const key = this._speedVariants.get(model.identifier)?.standard.identifier ?? ownTiers[0]?.identifier ?? model.identifier;
+        let card = this._detailsModelId === model.identifier ? this._detailsCard : undefined;
+        card ??= this._cards.get(key);
+        if (card) {
+            card.update(cardOptions);
+        } else {
+            card = ( new ModelCard(cardOptions));
+            this._cards.set(key, card);
+        }
+        return card;
+    }
+    _showModelDetails(model, focusConfiguration = false, returnFocusToRow = false) {
+        const context = this._context;
+        if (!context) {
+            return;
+        }
+        this._selectionVersion++;
+        this._detailsCard = undefined;
+        this._detailsModelId = model.identifier;
+        const card = this._getModelCard(model, context);
+        card.refresh();
+        this._detailsCard = card;
+        this._widget.showDetails({
+            label: ( localize(14592, "{0} Details", this._getRowLabel(model, context))),
+            backLabel: ( localize(14596, "Back to Models")),
+            renderHeader: container => {
+                container.appendChild(card.headerElement);
+                return toDisposable(() => card.headerElement.remove());
             },
-            hideIcon: false,
-            section,
-            className: badge ? `chat-model-picker-badge-${badge.tone}` : undefined,
-            hover: autoEnabled ? undefined : {
-                content: createCard,
-                expandable: true,
-                showIndicator: false,
-                panelClassName: "chat-model-card-panel",
-                alignToParent: true,
-                preserveVerticalPosition: true
+            render: container => {
+                const store = ( new DisposableStore());
+                const hint = context.configurationCacheBreakHint;
+                if (hint) {
+                    const message = hint.link ? `${hint.text} [${hint.link.label}](${( hint.link.uri.toString())})` : hint.text;
+                    const banner = createMessageBanner(
+                        message,
+                        "chat-model-picker-configuration-hint",
+                        Codicon.info,
+                        store,
+                        this._openerService
+                    );
+                    const actions = store.add(( new ActionBar(banner)));
+                    actions.push(toAction({
+                        id: "chat.modelPicker.dismissConfigurationHint",
+                        label: ( localize(14597, "Dismiss Hint")),
+                        class: ThemeIcon.asClassName(Codicon.close),
+                        run: () => {
+                            hint.dismiss();
+                            card.focus();
+                            banner.remove();
+                            if (this._context) {
+                                this._context = {
+                                    ...this._context,
+                                    cacheBreakHint: undefined,
+                                    configurationCacheBreakHint: undefined
+                                };
+                            }
+                            this._widget.refreshActiveList();
+                        }
+                    }), {
+                        icon: true,
+                        label: false
+                    });
+                    container.appendChild(banner);
+                }
+                container.appendChild(card.element);
+                store.add(toDisposable(() => card.element.remove()));
+                return store;
             },
-            tooltip: action.tooltip
-        };
+            focus: container => {
+                if (focusConfiguration) {
+                    card.focus();
+                } else {
+                    container.focus();
+                }
+            },
+            restoreFocus: () => returnFocusToRow ? this._widget.focusItem(this._detailsModelId ?? model.identifier) : this._widget.focusItemAction(this._detailsModelId ?? model.identifier, MODEL_DETAILS_ACTION_ID),
+            onBack: () => {
+                this._selectionVersion++;
+                this._detailsModelId = undefined;
+                this._detailsCard = undefined;
+            }
+        });
     }
     _togglePin(modelIdentifier, pinned) {
         const context = this._context;
@@ -444,58 +1016,40 @@ let TabbedModelPicker = class TabbedModelPicker extends Disposable {
             ...context,
             pinnedModelIds: pinned ? [...context.pinnedModelIds, modelIdentifier] : context.pinnedModelIds.filter(id => !pinnedVariantIds.includes(id))
         };
-        this._widget.refreshActiveList({
-            focusItemId: modelIdentifier,
-            preserveHover: true,
-            animateItemMove: true
-        });
+        this.refresh();
     }
-    _renderAutoRow(container, autoModel, context) {
-        const row = ( new ModelPickerAutoRow({
-            autoModel,
-            configurationAccess: context.configurationAccess,
-            isEnabled: () => this._isAutoSelected(this._context ?? context),
-            onToggle: enabled => this._toggleAuto(enabled, autoModel),
-            onDidChangeConfiguration: (group, key, fromValue, toValue) => context.onConfigurationChanged(autoModel, group, key, fromValue, toValue)
-        }));
-        this._autoRow.value = row;
-        container.appendChild(row.element);
-        return row;
-    }
-    _toggleAuto(enabled, autoModel) {
-        const context = this._context;
-        if (!context) {
-            return;
+    _applyModelSelection(model, context, resetWorkflow = true) {
+        if (resetWorkflow) {
+            context.workflow?.reset();
         }
-        const next = enabled ? autoModel : this._fallbackModel(context);
-        if (!next) {
-            this._autoRow.value?.render();
-            return;
-        }
-        this._selectionVersion++;
-        context.onSelect(next);
         this._context = {
             ...context,
-            selectedModelId: next.identifier
+            selectedModelId: model.identifier
         };
-        this._widget.refreshActiveList();
-        this._autoRow.value?.render();
+        this._rememberHydraFusionTier(this._context);
+        context.onSelect(model);
+    }
+    _rememberHydraFusionTier(context) {
+        if (( this._hydraFusionTiers(context).some(model => model.identifier === context.selectedModelId))) {
+            this._preferredHydraFusionTier = context.selectedModelId;
+        }
     }
     _fallbackModel(context) {
-        const candidates = [
-            this._lastExplicitModelId,
-            ...context.recentModelIds,
-            ...context.pinnedModelIds
-        ];
+        const isCandidate = model => !isAutoModel(model) && !isHydraFusionModel(model) && !isUserProvidedModel(model, this._languageModelsService) && !requiresNewerVSCode(
+            model,
+            context.controlModels,
+            context.unavailableContext.currentVSCodeVersion
+        );
+        const candidates = [...context.recentModelIds, ...context.pinnedModelIds];
         for (const id of candidates) {
             const model = context.models.find(candidate => candidate.identifier === id);
-            if (model && !isAutoModel(model)) {
+            if (model && isCandidate(model)) {
                 return model;
             }
         }
-        return context.models.find(model => !isAutoModel(model));
+        return context.models.find(isCandidate);
     }
 };
-TabbedModelPicker = ( __decorate([( __param(0, IInstantiationService)), ( __param(1, IChatEntitlementService)), ( __param(2, ILanguageModelsService)), ( __param(3, IOpenerService)), ( __param(4, IStorageService))], TabbedModelPicker));
+TabbedModelPicker = ( __decorate([( __param(0, IInstantiationService)), ( __param(1, IChatEntitlementService)), ( __param(2, ILanguageModelsService)), ( __param(3, IOpenerService)), ( __param(4, IStorageService)), ( __param(5, IConfigurationService)), ( __param(6, IContextViewService))], TabbedModelPicker));
 
 export { TabbedModelPicker };