@theia/ai-core 1.76.0-next.6 → 1.76.0

package/src/browser/favorite-models-service.spec.ts

@@ -0,0 +1,336 @@
+// *****************************************************************************
+// Copyright (C) 2026 EclipseSource GmbH.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { expect } from 'chai';
+import { PreferenceService } from '@theia/core';
+import { PREFERENCE_NAME_FAVORITE_MODELS, PREFERENCE_NAME_HIDDEN_MODELS } from '../common/ai-core-preferences';
+import { DiscoveredModel, ModelDiscoveryStatus } from '../common/model-discovery-status';
+import { FavoriteModelsService } from './favorite-models-service';
+import { ModelDiscoveryStatusService } from './model-discovery-status-service';
+
+function dated(id: string, released: string): DiscoveredModel {
+    return { id, released: Date.parse(released) };
+}
+
+function createService(
+    statuses: ModelDiscoveryStatus[],
+    marked: string[] = [],
+    hidden: string[] = []
+): { service: FavoriteModelsService; written: string[][]; stored: Record<string, string[]> } {
+    const service = new FavoriteModelsService();
+    const written: string[][] = [];
+    const stored: Record<string, string[]> = {
+        [PREFERENCE_NAME_FAVORITE_MODELS]: marked,
+        [PREFERENCE_NAME_HIDDEN_MODELS]: hidden
+    };
+    const discoveryStatus: Partial<ModelDiscoveryStatusService> = { getStatuses: () => statuses };
+    const preferenceService: Partial<PreferenceService> = {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        get: ((name: string, defaultValue: unknown) => stored[name] ?? defaultValue) as any,
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        set: (async (name: string, value: any) => { stored[name] = value; written.push(value); }) as any
+    };
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    (service as any).discoveryStatus = discoveryStatus;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    (service as any).preferenceService = preferenceService;
+    return { service, written, stored };
+}
+
+function status(overrides: Partial<ModelDiscoveryStatus> = {}): ModelDiscoveryStatus {
+    return { providerId: 'anthropic', label: 'Anthropic', state: 'ready', ...overrides };
+}
+
+describe('FavoriteModelsService', () => {
+
+    it('features the five most recently released undated models, never a release-pinned one', () => {
+        const { service } = createService([status({
+            discovered: [
+                dated('claude-opus-5', '2026-04-01'),
+                dated('claude-sonnet-5', '2026-02-01'),
+                dated('claude-haiku-4-5', '2025-10-01'),
+                dated('claude-fable-5', '2025-09-01'),
+                dated('claude-opus-4-8', '2025-08-01'),
+                dated('claude-opus-4-7', '2025-06-01'),
+                dated('claude-opus-5-20260401', '2026-04-01')
+            ]
+        })]);
+        expect(service.isFeatured('anthropic/claude-opus-5')).to.equal(true);
+        expect(service.isFeatured('anthropic/claude-opus-4-8')).to.equal(true);
+        // The sixth-newest falls outside the featured set.
+        expect(service.isFeatured('anthropic/claude-opus-4-7')).to.equal(false);
+        // A release-pinned id is never featured, however recent it is.
+        expect(service.isFeatured('anthropic/claude-opus-5-20260401')).to.equal(false);
+    });
+
+    it('caps a provider that reports no release dates by the versions in its ids', () => {
+        const { service } = createService([status({
+            providerId: 'google',
+            discovered: [
+                { id: 'gemini-2.0-pro' }, { id: 'gemini-2.5-flash' }, { id: 'gemini-2.5-pro' },
+                { id: 'gemini-3.1-pro-preview' }, { id: 'gemini-3.5-flash' }, { id: 'gemini-3.7-flash' }
+            ]
+        })]);
+        // The highest versions in the ids; the oldest of the six drops out.
+        expect(service.isFeatured('google/gemini-3.7-flash')).to.equal(true);
+        expect(service.isFeatured('google/gemini-2.5-pro')).to.equal(true);
+        expect(service.isFeatured('google/gemini-2.0-pro')).to.equal(false);
+    });
+
+    it('features a `-latest` pointer ahead of the versioned ids it stands for', () => {
+        const { service } = createService([status({
+            providerId: 'google',
+            discovered: [
+                { id: 'gemini-3.5-flash' }, { id: 'gemini-3.7-flash' }, { id: 'gemini-3.8-flash' },
+                { id: 'gemini-3.1-pro-preview' }, { id: 'gemini-2.5-pro' }, { id: 'gemini-flash-latest' }
+            ]
+        })]);
+        // The pointer carries no version, so without a rule of its own it would sort behind all of them.
+        expect(service.isFeatured('google/gemini-flash-latest')).to.equal(true);
+        expect(service.isFeatured('google/gemini-2.5-pro')).to.equal(false);
+    });
+
+    it('offers the pointers and the newest versions for a provider that reports no dates', () => {
+        const { service } = createService([status({
+            providerId: 'google',
+            discovered: [
+                { id: 'gemini-flash-latest' }, { id: 'gemini-flash-lite-latest' }, { id: 'gemini-pro-latest' },
+                { id: 'gemini-3.8-flash' }, { id: 'gemini-3.7-flash' }, { id: 'gemini-3.5-flash' },
+                { id: 'gemini-3.1-pro-preview' }, { id: 'gemini-2.5-pro' }
+            ]
+        })]);
+        expect(service.isFeatured('google/gemini-pro-latest')).to.equal(true);
+        expect(service.isFeatured('google/gemini-flash-latest')).to.equal(true);
+        expect(service.isFeatured('google/gemini-flash-lite-latest')).to.equal(true);
+        // The pointers first, then the newest concrete models fill the rest.
+        expect(service.isFeatured('google/gemini-3.8-flash')).to.equal(true);
+        expect(service.isFeatured('google/gemini-3.7-flash')).to.equal(true);
+        expect(service.isFeatured('google/gemini-3.1-pro-preview')).to.equal(false);
+    });
+
+    it('orders a `-latest` id by its release date where the provider reports one', () => {
+        const { service } = createService([status({
+            providerId: 'openAiOfficial',
+            modelIdPrefix: 'openai',
+            discovered: [
+                dated('gpt-5.6-sol', '2026-02-01'),
+                dated('gpt-5.5', '2025-11-01'),
+                dated('gpt-5.1', '2025-08-01'),
+                dated('gpt-5', '2025-06-01'),
+                dated('o4-mini', '2025-04-01'),
+                dated('chatgpt-4o-latest', '2024-08-01')
+            ]
+        })]);
+        // A provider that dates its models dates its pointers too, so the pointer rule stays out of it.
+        expect(service.isFeatured('openai/gpt-5.6-sol')).to.equal(true);
+        expect(service.isFeatured('openai/o4-mini')).to.equal(true);
+        expect(service.isFeatured('openai/chatgpt-4o-latest')).to.equal(false);
+    });
+
+    it('features what the provider reports as newest, whatever the model aliases name', () => {
+        const { service } = createService([status({
+            discovered: [
+                dated('claude-opus-5', '2026-04-01'),
+                dated('claude-sonnet-5', '2026-03-01'),
+                dated('claude-fable-5', '2026-02-01'),
+                dated('claude-opus-4-8', '2026-01-01'),
+                dated('claude-opus-4-7', '2025-12-01'),
+                // Named by the built-in aliases, and the oldest of the six: an alias is a curated list of
+                // its own, saying which model a purpose uses rather than which are worth offering here.
+                dated('claude-haiku-4-5', '2025-10-01')
+            ]
+        })]);
+        expect(service.isFeatured('anthropic/claude-opus-4-7')).to.equal(true);
+        expect(service.isFeatured('anthropic/claude-haiku-4-5')).to.equal(false);
+    });
+
+    it('prunes the marked and hidden models that a successful discovery no longer offers', () => {
+        const { service, stored } = createService(
+            [status({ discovered: [dated('claude-opus-5', '2026-04-01')] })],
+            ['anthropic/claude-gone', 'openai/gpt-5.5'],
+            ['anthropic/claude-also-gone', 'anthropic/claude-opus-5']
+        );
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        (service as any).pruneFavorites(status({ discovered: [dated('claude-opus-5', '2026-04-01')] }));
+        // Only the vanished models of that provider are dropped; another provider's stars are untouched.
+        expect(stored[PREFERENCE_NAME_FAVORITE_MODELS]).to.deep.equal(['openai/gpt-5.5']);
+        expect(stored[PREFERENCE_NAME_HIDDEN_MODELS]).to.deep.equal(['anthropic/claude-opus-5']);
+    });
+
+    it('keeps the marked models when the discovery did not actually reach the provider', () => {
+        const { service, written } = createService([], ['anthropic/claude-gone']);
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const prune = (candidate: ModelDiscoveryStatus) => (service as any).pruneFavorites(candidate);
+        prune(status({ state: 'ready', fromCache: true, discovered: [] }));
+        prune(status({ state: 'error' }));
+        prune(status({ state: 'no-credentials' }));
+        prune(status({ state: 'ready', discovered: undefined }));
+        expect(written).to.be.empty;
+    });
+
+    it('respects a provider that nominates its own models, as Copilot does across vendors', () => {
+        const { service } = createService([status({
+            providerId: 'copilot',
+            discovered: [
+                { id: 'auto', featured: true },
+                { id: 'gpt-5', featured: true },
+                { id: 'claude-sonnet-4.5', featured: true },
+                { id: 'gpt-4.1' },
+                { id: 'claude-haiku-4' },
+                { id: 'gemini-2.5-pro' }
+            ]
+        })]);
+        expect(service.isFeatured('copilot/auto')).to.equal(true);
+        expect(service.isFeatured('copilot/claude-sonnet-4.5')).to.equal(true);
+        // Not nominated, and the generic "five newest" ranking does not apply where a provider nominated.
+        expect(service.isFeatured('copilot/gpt-4.1')).to.equal(false);
+        expect(service.isFeatured('copilot/gemini-2.5-pro')).to.equal(false);
+    });
+
+    it('offers exactly what a nominating provider nominated, and nothing beside it', () => {
+        const { service } = createService([status({
+            providerId: 'copilot',
+            discovered: [{ id: 'gpt-5', featured: true }, { id: 'claude-haiku-4' }]
+        })]);
+        expect(service.isFeatured('copilot/gpt-5')).to.equal(true);
+        expect(service.isFeatured('copilot/claude-haiku-4')).to.equal(false);
+    });
+
+    it('features a manually configured list in full', () => {
+        const { service } = createService([status({
+            state: 'overridden',
+            discovered: [{ id: 'a' }, { id: 'b' }, { id: 'c' }, { id: 'd' }, { id: 'e' }, { id: 'f' }]
+        })]);
+        expect(service.isFeatured('anthropic/f')).to.equal(true);
+    });
+
+    it('honours the models the user marked', () => {
+        const { service } = createService(
+            [status({ discovered: [dated('claude-opus-5', '2026-04-01'), dated('claude-opus-4-7', '2024-06-01')] })],
+            ['anthropic/claude-opus-5-20260401']
+        );
+        expect(service.isFavorite('anthropic/claude-opus-5-20260401')).to.equal(true);
+        expect(service.isFavorite('anthropic/claude-opus-4-7')).to.equal(true); // featured, only two undated ids
+        expect(service.isFavorite('anthropic/claude-unknown')).to.equal(false);
+    });
+
+    it('treats the models of a provider that does not participate in discovery as favorites', () => {
+        const { service } = createService([status({ discovered: [dated('claude-opus-5', '2026-04-01')] })]);
+        // Manually configured providers (ollama, hugging face, …) and custom endpoints are the user's own list.
+        expect(service.isFavorite('ollama/llama3')).to.equal(true);
+        expect(service.isFavorite('my-custom-endpoint-model')).to.equal(true);
+    });
+
+    it('honours the model-id prefix when it differs from the provider id', () => {
+        const { service } = createService([status({
+            providerId: 'openAiOfficial',
+            modelIdPrefix: 'openai',
+            discovered: [dated('gpt-5.6-sol', '2026-02-01')]
+        })]);
+        expect(service.isFeatured('openai/gpt-5.6-sol')).to.equal(true);
+    });
+
+    describe('resetToDefaults', () => {
+
+        it('drops what the user decided about one provider and leaves the others alone', async () => {
+            const { service, stored } = createService(
+                [status({ discovered: [dated('claude-opus-5', '2026-04-01')] })],
+                ['anthropic/claude-opus-4-7', 'openai/gpt-5.5'],
+                ['anthropic/claude-opus-5', 'openai/gpt-5.6-sol']
+            );
+            expect(service.hasOverrides('anthropic')).to.equal(true);
+
+            await service.resetToDefaults('anthropic');
+
+            expect(stored[PREFERENCE_NAME_FAVORITE_MODELS]).to.deep.equal(['openai/gpt-5.5']);
+            expect(stored[PREFERENCE_NAME_HIDDEN_MODELS]).to.deep.equal(['openai/gpt-5.6-sol']);
+            expect(service.hasOverrides('anthropic')).to.equal(false);
+            expect(service.hasOverrides('openai')).to.equal(true);
+            // The provider is back to what it offers by default.
+            expect(service.isFavorite('anthropic/claude-opus-5')).to.equal(true);
+        });
+
+        it('writes nothing when there is nothing to reset', async () => {
+            const { service, written } = createService([status({ discovered: [dated('claude-opus-5', '2026-04-01')] })]);
+            expect(service.hasOverrides('anthropic')).to.equal(false);
+            await service.resetToDefaults('anthropic');
+            expect(written).to.be.empty;
+        });
+    });
+
+    describe('toggleFavorite', () => {
+
+        it('adds and removes an id the user can control', async () => {
+            const { service, written } = createService([status({ discovered: [dated('claude-opus-5', '2026-04-01')] })], []);
+            await service.toggleFavorite('anthropic/claude-opus-5-20260401');
+            expect(written[0]).to.deep.equal(['anthropic/claude-opus-5-20260401']);
+
+            const removing = createService([status({ discovered: [dated('claude-opus-5', '2026-04-01')] })], ['anthropic/claude-opus-5-20260401']);
+            await removing.service.toggleFavorite('anthropic/claude-opus-5-20260401');
+            expect(removing.written[0]).to.deep.equal([]);
+        });
+
+        it('hides a model that is offered by default, storing only that', async () => {
+            const { service, stored } = createService([status({ discovered: [dated('claude-opus-5', '2026-04-01')] })]);
+            expect(service.isFavorite('anthropic/claude-opus-5')).to.equal(true);
+
+            await service.toggleFavorite('anthropic/claude-opus-5');
+
+            expect(stored[PREFERENCE_NAME_HIDDEN_MODELS]).to.deep.equal(['anthropic/claude-opus-5']);
+            // Featured all the same, it is only kept out of the picker.
+            expect(service.isFeatured('anthropic/claude-opus-5')).to.equal(true);
+            expect(service.isFavorite('anthropic/claude-opus-5')).to.equal(false);
+            // Nothing is written to the favorites: a model offered by default was never listed there.
+            expect(stored[PREFERENCE_NAME_FAVORITE_MODELS]).to.be.empty;
+        });
+
+        it('shows a hidden model again by dropping its entry', async () => {
+            const { service, stored } = createService(
+                [status({ discovered: [dated('claude-opus-5', '2026-04-01')] })],
+                [],
+                ['anthropic/claude-opus-5']
+            );
+            expect(service.isFavorite('anthropic/claude-opus-5')).to.equal(false);
+
+            await service.toggleFavorite('anthropic/claude-opus-5');
+
+            expect(stored[PREFERENCE_NAME_HIDDEN_MODELS]).to.be.empty;
+            expect(stored[PREFERENCE_NAME_FAVORITE_MODELS]).to.be.empty;
+            expect(service.isFavorite('anthropic/claude-opus-5')).to.equal(true);
+        });
+
+        it('marks a model that fell out of the featured set while it was hidden', async () => {
+            const { service, stored } = createService(
+                [status({ discovered: [dated('claude-opus-5', '2026-04-01'), dated('claude-opus-4-7', '2024-06-01')] })],
+                [],
+                ['anthropic/claude-opus-5-20260401']
+            );
+            // Release-pinned, so never featured: dropping the entry alone would not bring it back.
+            await service.toggleFavorite('anthropic/claude-opus-5-20260401');
+
+            expect(stored[PREFERENCE_NAME_HIDDEN_MODELS]).to.be.empty;
+            expect(stored[PREFERENCE_NAME_FAVORITE_MODELS]).to.deep.equal(['anthropic/claude-opus-5-20260401']);
+            expect(service.isFavorite('anthropic/claude-opus-5-20260401')).to.equal(true);
+        });
+
+        it('hides a model of a provider that does not participate in discovery', async () => {
+            const { service, stored } = createService([status({ discovered: [dated('claude-opus-5', '2026-04-01')] })]);
+            await service.toggleFavorite('ollama/llama3');
+            expect(stored[PREFERENCE_NAME_HIDDEN_MODELS]).to.deep.equal(['ollama/llama3']);
+            expect(service.isFavorite('ollama/llama3')).to.equal(false);
+        });
+    });
+});

package/src/browser/favorite-models-service.ts

@@ -0,0 +1,297 @@
+// *****************************************************************************
+// Copyright (C) 2026 EclipseSource GmbH.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { Emitter, Event, PreferenceScope, PreferenceService } from '@theia/core';
+import { inject, injectable, postConstruct } from '@theia/core/shared/inversify';
+import { PREFERENCE_NAME_FAVORITE_MODELS, PREFERENCE_NAME_HIDDEN_MODELS } from '../common/ai-core-preferences';
+import { DiscoveredModel, ModelDiscoveryStatus } from '../common/model-discovery-status';
+import { DiscoveredModels } from '../common/model-discovery-util';
+import { ModelDiscoveryStatusService } from './model-discovery-status-service';
+
+/**
+ * How many of a provider's models are offered without the user asking. Enough to cover a provider's
+ * current line-up (a flagship, a fast one, a cheap one and their immediate predecessors) without
+ * turning the model pickers back into a catalogue.
+ */
+export const FEATURED_MODEL_COUNT = 5;
+
+/** What {@link FavoriteModelsService} derives from what the providers last reported. */
+export interface DerivedFavorites {
+    /** Fully qualified ids of the models that are offered without the user asking. */
+    readonly featured: Set<string>;
+    /** Model-id prefixes of the providers that participate in discovery. */
+    readonly discoveryPrefixes: Set<string>;
+}
+
+/**
+ * Decides which models the model picker in the AI chat input offers.
+ *
+ * Discovery registers everything a provider offers, including one entry per release, which is far
+ * more than anyone picks between while chatting. What that picker shows is therefore the *favorites*:
+ * the models that are featured automatically plus the ones the user marked. Everywhere a model is
+ * chosen deliberately — an agent's model, a model alias — every discovered model stays on offer.
+ *
+ * A model is featured when it is one of the {@link FEATURED_MODEL_COUNT} most recently released
+ * undated ids of its provider — so `claude-opus-5` is featured while `claude-opus-5-20260401` is
+ * not. Because the featured set is derived from each discovery rather than stored, a model released
+ * tomorrow is offered the day it appears, and the user cannot end up pinned to a stale line-up.
+ *
+ * Both directions are the user's to override, and only the override is stored: a model offered by
+ * default is taken out of the picker by an entry in {@link PREFERENCE_NAME_HIDDEN_MODELS}, any other
+ * model is put into it by an entry in {@link PREFERENCE_NAME_FAVORITE_MODELS}. A model nobody touched
+ * appears in neither.
+ *
+ * Models of a provider that does not participate in discovery — one whose models are configured by
+ * hand, or a custom endpoint — are all favorites: listing them *was* the user's choice.
+ */
+@injectable()
+export class FavoriteModelsService {
+
+    @inject(PreferenceService)
+    protected readonly preferenceService: PreferenceService;
+
+    @inject(ModelDiscoveryStatusService)
+    protected readonly discoveryStatus: ModelDiscoveryStatusService;
+
+    protected readonly onDidChangeEmitter = new Emitter<void>();
+    /** Fired when the marked models or the featured set change. */
+    readonly onDidChange: Event<void> = this.onDidChangeEmitter.event;
+
+    /** Memoized {@link getDerived}, dropped whenever a discovery reports something new. */
+    protected derived: DerivedFavorites | undefined;
+
+    @postConstruct()
+    protected init(): void {
+        this.discoveryStatus.onDidChange(status => {
+            this.derived = undefined;
+            this.pruneFavorites(status);
+            this.onDidChangeEmitter.fire();
+        });
+        this.preferenceService.onPreferenceChanged(event => {
+            if (event.preferenceName === PREFERENCE_NAME_FAVORITE_MODELS || event.preferenceName === PREFERENCE_NAME_HIDDEN_MODELS) {
+                this.onDidChangeEmitter.fire();
+            }
+        });
+    }
+
+    /** Whether the chat input's model picker offers this model, be it featured, marked or hand-configured. */
+    isFavorite(modelId: string): boolean {
+        if (this.getHidden().includes(modelId)) {
+            return false;
+        }
+        return this.isOfferedByDefault(modelId) || this.getFavorites().includes(modelId);
+    }
+
+    /**
+     * Whether the picker would offer this model without the user marking it: one of the newest of a
+     * provider that discovers, or any model of a provider that does not. Nothing was discovered for
+     * the latter, so its models are there because someone put them there - a manually configured
+     * provider, or a custom endpoint. That is choice enough.
+     */
+    protected isOfferedByDefault(modelId: string): boolean {
+        return !this.participatesInDiscovery(modelId) || this.isFeatured(modelId);
+    }
+
+    /** Whether the model's provider reports a discovery status, i.e. whether featuring applies to it at all. */
+    protected participatesInDiscovery(modelId: string): boolean {
+        const separator = modelId.indexOf('/');
+        if (separator <= 0) {
+            return false;
+        }
+        return this.getDerived().discoveryPrefixes.has(modelId.substring(0, separator));
+    }
+
+    /**
+     * Whether the model is offered automatically because it is among its provider's newest, in which
+     * case it cannot be unmarked.
+     */
+    isFeatured(modelId: string): boolean {
+        return this.getFeatured().has(modelId);
+    }
+
+    /** The ids the user marked explicitly, the ones offered by default excluded. */
+    getFavorites(): string[] {
+        return this.preferenceService.get<string[]>(PREFERENCE_NAME_FAVORITE_MODELS, []);
+    }
+
+    /** The ids the user took out of the picker, which would otherwise be offered by default. */
+    getHidden(): string[] {
+        return this.preferenceService.get<string[]>(PREFERENCE_NAME_HIDDEN_MODELS, []);
+    }
+
+    /**
+     * Whether the user decided anything about this provider's models, i.e. whether resetting it to the
+     * models it offers by default would change what the picker shows.
+     *
+     * @param modelIdPrefix prefix of the provider's registered model ids, e.g. `openai`
+     */
+    hasOverrides(modelIdPrefix: string): boolean {
+        return [...this.getFavorites(), ...this.getHidden()].some(id => id.startsWith(`${modelIdPrefix}/`));
+    }
+
+    /**
+     * Drops what the user decided about one provider's models, so the picker shows the models that
+     * provider offers by default again. The other providers are left alone.
+     *
+     * @param modelIdPrefix prefix of the provider's registered model ids, e.g. `openai`
+     */
+    async resetToDefaults(modelIdPrefix: string): Promise<void> {
+        for (const preferenceName of [PREFERENCE_NAME_FAVORITE_MODELS, PREFERENCE_NAME_HIDDEN_MODELS]) {
+            const ids = this.preferenceService.get<string[]>(preferenceName, []);
+            const kept = ids.filter(id => !id.startsWith(`${modelIdPrefix}/`));
+            if (kept.length !== ids.length) {
+                await this.write(preferenceName, kept);
+            }
+        }
+    }
+
+    /**
+     * Puts a model into the picker or takes it out of it, whichever the current state calls for. Only
+     * the deviation from the default is stored: a model offered by default is taken out by an entry in
+     * the hidden list, and any other by dropping its entry from the favorites (or adding one).
+     */
+    async toggleFavorite(modelId: string): Promise<void> {
+        const favorites = this.getFavorites();
+        const hidden = this.getHidden();
+        if (this.isFavorite(modelId)) {
+            if (favorites.includes(modelId)) {
+                await this.write(PREFERENCE_NAME_FAVORITE_MODELS, favorites.filter(id => id !== modelId));
+            }
+            if (this.isOfferedByDefault(modelId)) {
+                await this.write(PREFERENCE_NAME_HIDDEN_MODELS, [...hidden, modelId]);
+            }
+            return;
+        }
+        if (hidden.includes(modelId)) {
+            await this.write(PREFERENCE_NAME_HIDDEN_MODELS, hidden.filter(id => id !== modelId));
+        }
+        // A model that was hidden while it was featured and has since fallen out of the featured set
+        // needs a mark of its own, or removing the entry would not bring it back.
+        if (!this.isOfferedByDefault(modelId)) {
+            await this.write(PREFERENCE_NAME_FAVORITE_MODELS, [...favorites, modelId]);
+        }
+    }
+
+    protected async write(preferenceName: string, ids: string[]): Promise<void> {
+        await this.preferenceService.set(preferenceName, ids, PreferenceScope.User);
+    }
+
+    /** The featured ids across all providers that participate in discovery, fully qualified. */
+    protected getFeatured(): Set<string> {
+        return this.getDerived().featured;
+    }
+
+    /**
+     * What the last discovery implies, computed once and kept until it changes. The chat input asks
+     * per model on every render, and ranking each provider's models per question would mean sorting
+     * the whole catalogue as many times as it has entries.
+     */
+    protected getDerived(): DerivedFavorites {
+        if (!this.derived) {
+            const featured = new Set<string>();
+            const discoveryPrefixes = new Set<string>();
+            for (const status of this.discoveryStatus.getStatuses()) {
+                const prefix = status.modelIdPrefix ?? status.providerId;
+                discoveryPrefixes.add(prefix);
+                for (const model of this.selectFeatured(status)) {
+                    featured.add(`${prefix}/${model.id}`);
+                }
+            }
+            this.derived = { featured, discoveryPrefixes };
+        }
+        return this.derived;
+    }
+
+    /**
+     * The models of one provider that are offered automatically: at most {@link FEATURED_MODEL_COUNT}
+     * of its undated ids. A release-pinned id is never featured — the undated form of the same model
+     * already is, and pinning a release is the deliberate choice the switch on its row makes.
+     *
+     * They are ranked by what the provider reports about them, in that order:
+     *
+     * 1. most recently released, where the provider reports release dates (Anthropic, OpenAI);
+     * 2. a `-latest` pointer the provider maintains at the current model of a family, which only
+     *    decides where there are no dates: a provider that reports them dates its pointers as well;
+     * 3. highest version in the id, which is what is left for Gemini — the naming of those models
+     *    carries their generation (`gemini-3.7-flash` over `gemini-2.5-pro`).
+     *
+     * What the model aliases name has no say in this: an alias is a curated list of its own, pointing
+     * at the model a purpose should use, which is a different question from which models are worth
+     * offering in the picker.
+     *
+     * An explicitly configured list (`modelOverrides`) is featured in full: the user named it. So is a
+     * provider's own nomination ({@link DiscoveredModel.featured}), which a provider makes when the
+     * generic ranking cannot serve it — Copilot carries models of many vendors and nominates one each
+     * of the three the other providers offer directly, where "the newest five" would pick five of
+     * whichever vendor numbers its models highest.
+     */
+    protected selectFeatured(status: ModelDiscoveryStatus): DiscoveredModel[] {
+        const discovered = status.discovered ?? [];
+        if (status.state === 'overridden') {
+            return [...discovered];
+        }
+        const nominated = discovered.filter(model => model.featured);
+        if (nominated.length > 0) {
+            return nominated;
+        }
+        return discovered
+            .filter(model => DiscoveredModels.undatedId(model.id) === undefined)
+            .map((model, index) => ({ model, index }))
+            .sort((left, right) => this.compareFeatured(left, right))
+            .slice(0, FEATURED_MODEL_COUNT)
+            .map(entry => entry.model);
+    }
+
+    /** Orders two candidates of the same provider; `index` preserves the reported order as the last resort. */
+    protected compareFeatured(
+        left: { model: DiscoveredModel; index: number },
+        right: { model: DiscoveredModel; index: number }
+    ): number {
+        const byRelease = (right.model.released ?? 0) - (left.model.released ?? 0);
+        if (byRelease !== 0) {
+            return byRelease;
+        }
+        // Only where a provider reports no dates: a pointer at its current model of a family is as
+        // current as a model gets, and it carries no version, so it would otherwise sort behind every
+        // id that does. Where there are dates, the pointer carries one too and has been ordered by it.
+        const byPointer = Number(DiscoveredModels.isLatestPointer(right.model.id)) - Number(DiscoveredModels.isLatestPointer(left.model.id));
+        if (byPointer !== 0) {
+            return byPointer;
+        }
+        const byVersion = DiscoveredModels.compareByVersion(left.model.id, right.model.id);
+        return byVersion !== 0 ? byVersion : left.index - right.index;
+    }
+
+    /**
+     * Drops the marked and hidden ids of a provider that a successful discovery no longer offers, so
+     * that neither list accumulates models that no longer exist. Only a live discovery prunes: a
+     * cached result, a failure or a missing credential says nothing about what the provider offers.
+     */
+    protected pruneFavorites(status: ModelDiscoveryStatus): void {
+        if (status.state !== 'ready' || status.fromCache || !status.discovered) {
+            return;
+        }
+        const prefix = status.modelIdPrefix ?? status.providerId;
+        const offered = new Set(status.discovered.map(model => `${prefix}/${model.id}`));
+        for (const preferenceName of [PREFERENCE_NAME_FAVORITE_MODELS, PREFERENCE_NAME_HIDDEN_MODELS]) {
+            const ids = this.preferenceService.get<string[]>(preferenceName, []);
+            const kept = ids.filter(id => !id.startsWith(`${prefix}/`) || offered.has(id));
+            if (kept.length !== ids.length) {
+                this.write(preferenceName, kept);
+            }
+        }
+    }
+}

package/src/browser/frontend-language-model-alias-registry.ts

@@ -67,7 +67,7 @@ export class DefaultLanguageModelAliasRegistry implements LanguageModelAliasRegi
             defaultModelIds: [
                 'anthropic/claude-haiku-4-5',
                 'openai/gpt-5.6-luna',
-                'google/gemini-3.7-flash'
+                'google/gemini-3.8-flash'
             ],
             description: nls.localize('theia/ai/core/defaultModelAliases/fast/description',
                 'Faster and cheaper models for simpler tasks like exploration or basic tool calling, where deep reasoning is not required.')