@theia/ai-core 1.76.0-next.28 → 1.76.0-next.34

package/src/browser/discovering-provider-contribution.ts

@@ -0,0 +1,241 @@
+// *****************************************************************************
+// 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 { MessageService, nls, PreferenceChange, PreferenceScope, PreferenceService } from '@theia/core';
+import { FrontendApplicationContribution } from '@theia/core/lib/browser';
+import { inject, injectable } from '@theia/core/shared/inversify';
+import { ApiKeySource, DiscoveredModel, ModelDiscoveryResult } from '../common/model-discovery-status';
+import { ModelDiscoveryStatusService } from './model-discovery-status-service';
+
+/** The part of a provider's language model manager that a discovery run drives. */
+export interface DiscoveringLanguageModelsManager<T> {
+    /** Asks the provider which models it offers; see {@link ModelDiscoveryResult} for the failure cases. */
+    fetchAvailableModels(): Promise<ModelDiscoveryResult>;
+    /** Where the effective API key comes from, which decides whether a run can proceed. */
+    getApiKeySource(): Promise<ApiKeySource>;
+    /** Allows or refuses the use of an API key found in the environment. */
+    setAllowEnvironmentApiKey(allowed: boolean): void;
+    createOrUpdateLanguageModels(...modelDescriptions: T[]): Promise<void>;
+    removeLanguageModels(...modelIds: string[]): void;
+}
+
+/**
+ * What a discovery run tells the user, in the provider's own words. Each message names the provider
+ * and its key, so they cannot be shared: a localization key has to be a literal to be extracted.
+ */
+export interface ModelDiscoveryMessages {
+    /** No credential is configured at all, and where to put one. */
+    readonly noCredentials: string;
+    /** An API key was found in the environment and waits for the user's confirmation. */
+    readonly consentRequired: string;
+    /** The question that asks for that confirmation, naming the environment variable it found. */
+    readonly consentPrompt: string;
+    /** Label of the button that grants it. */
+    readonly useEnvironmentKey: string;
+    /** The model list is configured by hand, so the provider is not asked what it offers. */
+    readonly overridden: string;
+    /** Cached models are being served because the last refresh failed with `error`. */
+    cached(error: string): string;
+}
+
+/**
+ * The shared half of a provider that discovers its language models: it asks the provider what it
+ * offers, registers the answer, unregisters what disappeared, and reports the state of all of that
+ * to the {@link ModelDiscoveryStatusService} so the provider's page can show it.
+ *
+ * A provider brings what only it can know: its id, its manager, the preferences it reads, how a
+ * discovered model becomes a model description, and the messages that name it. Everything a provider
+ * does beyond discovery (a custom endpoint, a proxy, its own retry settings) stays in the subclass,
+ * which hooks into {@link initializeProvider} and {@link handlePreferenceChange}.
+ */
+@injectable()
+export abstract class DiscoveringProviderContribution<T> implements FrontendApplicationContribution {
+
+    @inject(PreferenceService)
+    protected readonly preferenceService: PreferenceService;
+
+    @inject(ModelDiscoveryStatusService)
+    protected readonly discoveryStatus: ModelDiscoveryStatusService;
+
+    @inject(MessageService)
+    protected readonly messageService: MessageService;
+
+    /** Provider node id, e.g. `anthropic`. Matches the provider's node in the Models category. */
+    protected abstract readonly providerId: string;
+    /** Human-readable provider name, e.g. `Anthropic`. */
+    protected abstract readonly providerLabel: string;
+    protected abstract readonly manager: DiscoveringLanguageModelsManager<T>;
+    /** Preference holding an explicit model list that replaces discovery. */
+    protected abstract readonly modelOverridesPreference: string;
+    /** Preference holding the consent to use an API key found in the environment. */
+    protected abstract readonly allowEnvironmentApiKeyPreference: string;
+
+    /** Prefix of this provider's registered model ids. Defaults to {@link providerId}. */
+    protected get modelIdPrefix(): string {
+        return this.providerId;
+    }
+
+    protected abstract get discoveryMessages(): ModelDiscoveryMessages;
+
+    /** Turns a model the provider reported into the description its manager registers. */
+    protected abstract createModelDescription(model: DiscoveredModel): T;
+
+    /** The models registered from the last discovery, as the provider reported them. */
+    protected discoveredModels: DiscoveredModel[] = [];
+    /** Ensures the env-key consent prompt is shown at most once per session. */
+    protected envConsentPrompted = false;
+    protected discovering: Promise<void> = Promise.resolve();
+
+    onStart(): void {
+        this.preferenceService.ready.then(() => {
+            // Before any key is read: an environment key stays unused until it has been confirmed.
+            this.manager.setAllowEnvironmentApiKey(this.isEnvironmentApiKeyAllowed());
+            this.initializeProvider();
+
+            this.discoveryStatus.registerProvider({
+                providerId: this.providerId,
+                label: this.providerLabel,
+                modelIdPrefix: this.modelIdPrefix === this.providerId ? undefined : this.modelIdPrefix,
+                refresh: () => this.discoverAndRegisterModels()
+            });
+            this.discoverAndRegisterModels();
+
+            this.preferenceService.onPreferenceChanged(event => {
+                if (event.preferenceName === this.allowEnvironmentApiKeyPreference || event.preferenceName === this.modelOverridesPreference) {
+                    // Withdrawing the consent has to stop the key being used, not just stop discovering.
+                    this.manager.setAllowEnvironmentApiKey(this.isEnvironmentApiKeyAllowed());
+                    this.discoverAndRegisterModels();
+                } else {
+                    this.handlePreferenceChange(event);
+                }
+            });
+        });
+    }
+
+    /**
+     * Hands the provider's own configuration to its manager, before the first discovery run asks it
+     * anything. Also the place to register the models and listeners that discovery does not cover.
+     */
+    protected initializeProvider(): void {
+    }
+
+    /** Handles a change to a preference of this provider that is not part of discovery itself. */
+    protected handlePreferenceChange(event: PreferenceChange): void {
+    }
+
+    /** Fetches what the provider offers and registers it, removing whatever disappeared. */
+    protected async discoverAndRegisterModels(): Promise<void> {
+        // Runs are queued rather than overlapped: startup, a key change and a manual refresh can all
+        // ask within a moment of each other, and two runs in flight would compute what to unregister
+        // from the same stale list and leave the registry disagreeing with the provider.
+        this.discovering = this.discovering.then(() => this.runDiscovery().catch(error => this.discoveryStatus.reportError(this.providerId, error)));
+        return this.discovering;
+    }
+
+    protected async runDiscovery(): Promise<void> {
+        // A configured model list replaces discovery entirely: the provider is not asked what it
+        // offers, so the list is exactly what was configured. This is what pins a catalogue against
+        // provider changes, and the way to name models when the list endpoint cannot be reached at all.
+        const overrides = this.getModelOverrides();
+        if (overrides.length > 0) {
+            const configured = overrides.map(id => ({ id }));
+            await this.applyDiscoveredModels(configured);
+            this.discoveryStatus.updateStatus(this.providerId, {
+                state: 'overridden',
+                discovered: configured,
+                message: this.discoveryMessages.overridden,
+                lastFetch: undefined,
+                fromCache: false
+            });
+            return;
+        }
+        const source = await this.manager.getApiKeySource();
+        if (source === 'none') {
+            this.removeAllDiscoveredModels();
+            this.discoveryStatus.updateStatus(this.providerId, { state: 'no-credentials', message: this.discoveryMessages.noCredentials });
+            return;
+        }
+        // An API key from the environment is only used once the user has confirmed it.
+        if (source === 'environment' && !this.isEnvironmentApiKeyAllowed()) {
+            this.removeAllDiscoveredModels();
+            this.discoveryStatus.updateStatus(this.providerId, { state: 'awaiting-consent', message: this.discoveryMessages.consentRequired });
+            this.promptEnvironmentApiKeyConsentOnce();
+            return;
+        }
+        this.discoveryStatus.updateStatus(this.providerId, { state: 'fetching', message: undefined });
+        const { models, fromCache, error } = await this.manager.fetchAvailableModels();
+        await this.applyDiscoveredModels(models);
+        this.discoveryStatus.updateStatus(this.providerId, {
+            state: 'ready',
+            discovered: models,
+            // When served from cache after a failed refresh, keep the models usable but flag staleness.
+            message: fromCache && error ? this.discoveryMessages.cached(error) : undefined,
+            lastFetch: fromCache ? undefined : Date.now(),
+            fromCache
+        });
+    }
+
+    /** Registers the discovered models and unregisters the ones that are no longer offered. */
+    protected async applyDiscoveredModels(models: DiscoveredModel[]): Promise<void> {
+        const modelIds = models.map(model => model.id);
+        const removed = this.discoveredModels.filter(model => !modelIds.includes(model.id));
+        this.manager.removeLanguageModels(...removed.map(model => this.qualifiedModelId(model.id)));
+        await this.manager.createOrUpdateLanguageModels(...models.map(model => this.createModelDescription(model)));
+        this.discoveredModels = models;
+    }
+
+    /** Re-applies the descriptions of the already-discovered models, after a preference that feeds them changed. */
+    protected updateDiscoveredModels(): void {
+        this.manager.createOrUpdateLanguageModels(...this.discoveredModels.map(model => this.createModelDescription(model)));
+    }
+
+    protected removeAllDiscoveredModels(): void {
+        if (this.discoveredModels.length > 0) {
+            this.manager.removeLanguageModels(...this.discoveredModels.map(model => this.qualifiedModelId(model.id)));
+            this.discoveredModels = [];
+        }
+    }
+
+    protected qualifiedModelId(modelId: string): string {
+        return `${this.modelIdPrefix}/${modelId}`;
+    }
+
+    protected getModelOverrides(): string[] {
+        return this.preferenceService.get<string[]>(this.modelOverridesPreference, []);
+    }
+
+    protected isEnvironmentApiKeyAllowed(): boolean {
+        return this.preferenceService.get<boolean>(this.allowEnvironmentApiKeyPreference, false);
+    }
+
+    /**
+     * Asks the user once per session to confirm using an environment-provided API key. Confirming
+     * persists {@link allowEnvironmentApiKeyPreference}, which re-triggers discovery.
+     */
+    protected promptEnvironmentApiKeyConsentOnce(): void {
+        if (this.envConsentPrompted) {
+            return;
+        }
+        this.envConsentPrompted = true;
+        const useKey = this.discoveryMessages.useEnvironmentKey;
+        const ignore = nls.localizeByDefault('Ignore');
+        this.messageService.info(this.discoveryMessages.consentPrompt, useKey, ignore).then(choice => {
+            if (choice === useKey) {
+                this.preferenceService.set(this.allowEnvironmentApiKeyPreference, true, PreferenceScope.User);
+            }
+        });
+    }
+}

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);
+        });
+    });
+});