@theia/ai-ide 1.75.0-next.8 → 1.75.0

package/src/browser/ai-configuration/categories/model-aliases-configuration-category.tsx

@@ -0,0 +1,286 @@
+// *****************************************************************************
+// Copyright (C) 2026 EclipseSource and others.
+//
+// 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 { AgentService, AISettingsService, LANGUAGE_MODEL_ALIASES_PREFERENCE } from '@theia/ai-core';
+import { FrontendLanguageModelRegistry, LanguageModel, LanguageModelRegistry, LanguageModelRequirement } from '@theia/ai-core/lib/common/language-model';
+import { LanguageModelAlias, LanguageModelAliasRegistry } from '@theia/ai-core/lib/common/language-model-alias';
+import { Emitter, Event, nls } from '@theia/core';
+import { codicon } from '@theia/core/lib/browser';
+import { SelectOption } from '@theia/core/lib/browser/widgets/select-component';
+import { DisposableCollection } from '@theia/core/lib/common';
+import { inject, injectable, postConstruct } from '@theia/core/shared/inversify';
+import * as React from '@theia/core/shared/react';
+import {
+    AiConfigurationCategory,
+    AiConfigurationCategoryId,
+    AiConfigurationCategoryOrder,
+    AiConfigurationItemStatus,
+    AiConfigurationRenderContext,
+    AiConfigurationSearchItem,
+    AiConfigurationSearchProvider,
+    AiConfigurationTreeItem
+} from '@theia/ai-core-ui/lib/browser/ai-configuration/ai-configuration-category';
+import { CollectionCategoryRenderer } from '@theia/ai-core-ui/lib/browser/ai-configuration/renderers/collection-category-renderer';
+import { AiConfigurationSection } from '@theia/ai-core-ui/lib/browser/ai-configuration/components/ai-configuration-primitives';
+import { AiEnumSelect } from '@theia/ai-core-ui/lib/browser/ai-configuration/components/ai-configuration-controls';
+import { AgentChips } from './agent-chips';
+
+/** Sentinel option value representing "use the alias' default priority list" (no explicit model). */
+const DEFAULT_LIST_VALUE = '';
+
+/**
+ * The Model Aliases category: a `collection` porting the alias configuration onto the shared
+ * primitives. The per-item detail (selected model, priority list, resolved model, agents using
+ * the alias) is rendered synchronously from caches refreshed on the relevant service events.
+ */
+@injectable()
+export class ModelAliasesConfigurationCategory extends CollectionCategoryRenderer implements AiConfigurationCategory, AiConfigurationSearchProvider {
+
+    readonly id = AiConfigurationCategoryId.MODEL_ALIASES;
+    readonly label = nls.localize('theia/ai/core/modelAliasesConfiguration/label', 'Model Aliases');
+    readonly description = nls.localize('theia/ai/core/modelAliasesConfiguration/description',
+        'Named references to a preferred model, so agents can target a role instead of a specific model.');
+    readonly iconClass = codicon('symbol-namespace');
+    readonly order = AiConfigurationCategoryOrder.MODEL_ALIASES;
+    readonly kind = 'collection' as const;
+
+    @inject(LanguageModelAliasRegistry)
+    protected readonly languageModelAliasRegistry: LanguageModelAliasRegistry;
+
+    @inject(LanguageModelRegistry)
+    protected readonly languageModelRegistry: FrontendLanguageModelRegistry;
+
+    @inject(AISettingsService)
+    protected readonly aiSettingsService: AISettingsService;
+
+    @inject(AgentService)
+    protected readonly agentService: AgentService;
+
+    protected readonly onDidChangeEmitter = new Emitter<void>();
+    readonly onDidChange: Event<void> = this.onDidChangeEmitter.event;
+    protected readonly toDispose = new DisposableCollection(this.onDidChangeEmitter);
+
+    protected aliases: LanguageModelAlias[] = [];
+    protected languageModels: LanguageModel[] = [];
+    protected matchingAgentIdsForAlias = new Map<string, string[]>();
+    protected resolvedModelForAlias = new Map<string, LanguageModel | undefined>();
+
+    get renderer(): this {
+        return this;
+    }
+
+    getOwnedPreferenceIds(): string[] {
+        return [LANGUAGE_MODEL_ALIASES_PREFERENCE];
+    }
+
+    get search(): AiConfigurationSearchProvider {
+        return this;
+    }
+
+    @postConstruct()
+    protected init(): void {
+        Promise.all([this.loadAliases(), this.loadLanguageModels()]).then(() => this.onDidChangeEmitter.fire());
+        this.languageModelAliasRegistry.ready.then(() =>
+            this.toDispose.push(this.languageModelAliasRegistry.onDidChange(() => this.reload()))
+        );
+        this.toDispose.pushAll([
+            this.languageModelRegistry.onChange(async () => {
+                await this.loadLanguageModels();
+                await this.loadAliases();
+                this.onDidChangeEmitter.fire();
+            }),
+            this.aiSettingsService.onDidChange(async () => {
+                await this.loadMatchingAgents();
+                this.onDidChangeEmitter.fire();
+            })
+        ]);
+    }
+
+    dispose(): void {
+        this.toDispose.dispose();
+    }
+
+    protected async reload(): Promise<void> {
+        await this.loadAliases();
+        this.onDidChangeEmitter.fire();
+    }
+
+    protected async loadLanguageModels(): Promise<void> {
+        this.languageModels = await this.languageModelRegistry.getLanguageModels();
+    }
+
+    protected async loadAliases(): Promise<void> {
+        await this.languageModelAliasRegistry.ready;
+        this.aliases = this.languageModelAliasRegistry.getAliases().sort((a, b) => a.id.localeCompare(b.id));
+        await this.loadMatchingAgents();
+        this.resolvedModelForAlias = new Map();
+        for (const alias of this.aliases) {
+            this.resolvedModelForAlias.set(alias.id, await this.languageModelRegistry.getReadyLanguageModel(alias.id));
+        }
+    }
+
+    protected async loadMatchingAgents(): Promise<void> {
+        const agents = this.agentService.getAllAgents();
+        const aliasMap = new Map<string, string[]>();
+        for (const alias of this.aliases) {
+            const matchingAgentIds: string[] = [];
+            for (const agent of agents) {
+                const requirementSetting = await this.aiSettingsService.getAgentSettings(agent.id);
+                if (requirementSetting?.languageModelRequirements) {
+                    if (requirementSetting.languageModelRequirements.find(requirement => requirement.identifier === alias.id)) {
+                        matchingAgentIds.push(agent.id);
+                    }
+                } else if (agent.languageModelRequirements.some((requirement: LanguageModelRequirement) => requirement.identifier === alias.id)) {
+                    matchingAgentIds.push(agent.id);
+                }
+            }
+            aliasMap.set(alias.id, matchingAgentIds);
+        }
+        this.matchingAgentIdsForAlias = aliasMap;
+    }
+
+    protected get categoryId(): string {
+        return this.id;
+    }
+
+    getTreeChildren(): AiConfigurationTreeItem[] {
+        return this.aliases.map(alias => ({
+            id: alias.id,
+            label: alias.id,
+            description: alias.description,
+            status: this.getAliasStatus(alias)
+        } satisfies AiConfigurationTreeItem));
+    }
+
+    protected getAliasStatus(alias: LanguageModelAlias): AiConfigurationItemStatus {
+        const resolved = this.resolvedModelForAlias.get(alias.id);
+        if (!resolved) {
+            return {
+                kind: 'error',
+                label: nls.localize('theia/ai/core/modelAliasesConfiguration/noModel', 'No model'),
+                tooltip: nls.localize('theia/ai/core/modelAliasesConfiguration/noResolvedModel', 'No model ready for this alias.')
+            };
+        }
+        const modelName = resolved.name ?? resolved.id;
+        if (resolved.status.status !== 'ready') {
+            return {
+                kind: 'warn',
+                label: nls.localize('theia/ai/core/modelAliasesConfiguration/notReady', 'Not ready'),
+                tooltip: resolved.status.message
+            };
+        }
+        // Show what the alias actually resolves to rather than a generic "Ready", so the badge is informative.
+        return {
+            kind: 'on',
+            label: modelName,
+            tooltip: nls.localize('theia/ai/core/modelAliasesConfiguration/resolvesTo', 'Resolves to {0}', modelName)
+        };
+    }
+
+    protected renderItemSections(item: AiConfigurationTreeItem, ctx: AiConfigurationRenderContext): React.ReactNode {
+        const alias = this.aliases.find(candidate => candidate.id === item.id);
+        if (!alias) {
+            return undefined;
+        }
+        return <>
+            {this.renderSelectedModel(alias)}
+            {alias.selectedModelId === undefined && this.renderPriorityList(alias)}
+            {this.renderAgentsUsingAlias(alias, ctx)}
+        </>;
+    }
+
+    protected renderSelectedModel(alias: LanguageModelAlias): React.ReactNode {
+        const options = this.getModelOptions();
+        const selected = alias.selectedModelId ?? DEFAULT_LIST_VALUE;
+        const isInvalid = !!alias.selectedModelId && !this.languageModels.some(model => model.id === alias.selectedModelId);
+        return <AiConfigurationSection title={nls.localize('theia/ai/core/modelAliasesConfiguration/selectedModelId', 'Selected Model')}>
+            {isInvalid && <div className='ai-alias-invalid-model'>
+                {nls.localize('theia/ai/core/modelAliasesConfiguration/unavailableModel', 'Selected model is no longer available')}
+            </div>}
+            <AiEnumSelect
+                ariaLabel={nls.localize('theia/ai/core/modelAliasesConfiguration/selectedModelId', 'Selected Model')}
+                value={isInvalid ? undefined : selected}
+                invalid={isInvalid}
+                options={options.map(option => ({ value: String(option.value ?? ''), label: option.label ?? String(option.value ?? ''), title: option.description }))}
+                onCommit={value => this.setSelectedModel(alias, value)}
+            />
+        </AiConfigurationSection>;
+    }
+
+    protected getModelOptions(): SelectOption[] {
+        const options: SelectOption[] = [{
+            value: DEFAULT_LIST_VALUE,
+            label: nls.localize('theia/ai/core/modelAliasesConfiguration/defaultList', '[Default list]')
+        }];
+        for (const model of [...this.languageModels].sort((a, b) => (a.name ?? a.id).localeCompare(b.name ?? b.id))) {
+            const ready = model.status.status === 'ready';
+            options.push({
+                value: model.id,
+                label: `${model.name ?? model.id} ${ready ? '✓' : '✗'}`,
+                description: !ready ? model.status.message : undefined
+            });
+        }
+        return options;
+    }
+
+    protected setSelectedModel(alias: LanguageModelAlias, value: string | undefined): void {
+        const selectedModelId = value ? value : undefined;
+        this.languageModelAliasRegistry.ready.then(() => this.languageModelAliasRegistry.addAlias({ ...alias, selectedModelId }));
+    }
+
+    protected renderPriorityList(alias: LanguageModelAlias): React.ReactNode {
+        const resolved = this.resolvedModelForAlias.get(alias.id);
+        return <>
+            <AiConfigurationSection title={nls.localize('theia/ai/core/modelAliasesConfiguration/priorityList', 'Priority List')}>
+                <ol>
+                    {alias.defaultModelIds.map(modelId => {
+                        const model = this.languageModels.find(candidate => candidate.id === modelId);
+                        const ready = model?.status.status === 'ready';
+                        return <li key={modelId} className={modelId === resolved?.id ? 'ai-alias-priority-item-resolved' : undefined}>
+                            {modelId} {ready ? '✓' : '✗'}
+                        </li>;
+                    })}
+                </ol>
+            </AiConfigurationSection>
+            <AiConfigurationSection title={nls.localize('theia/ai/core/modelAliasesConfiguration/evaluatesTo', 'Evaluates to')}>
+                {resolved
+                    ? <span>{resolved.name ?? resolved.id} {resolved.status.status === 'ready' ? '✓' : '✗'}</span>
+                    : <span>{nls.localize('theia/ai/core/modelAliasesConfiguration/noResolvedModel', 'No model ready for this alias.')}</span>}
+            </AiConfigurationSection>
+        </>;
+    }
+
+    protected renderAgentsUsingAlias(alias: LanguageModelAlias, ctx: AiConfigurationRenderContext): React.ReactNode {
+        const agentIds = this.matchingAgentIdsForAlias.get(alias.id) ?? [];
+        const agents = this.agentService.getAllAgents().filter(agent => agentIds.includes(agent.id));
+        return <AiConfigurationSection title={nls.localize('theia/ai/core/modelAliasesConfiguration/agents', 'Agents using this Alias')}>
+            {agents.length > 0
+                ? <AgentChips agents={agents} onOpenAgent={agentId => ctx.navigate({ categoryId: AiConfigurationCategoryId.AGENTS, itemId: agentId })} />
+                : <span>{nls.localize('theia/ai/core/modelAliasesConfiguration/noAgents', 'No agents use this alias.')}</span>}
+        </AiConfigurationSection>;
+    }
+
+    getSearchItems(): AiConfigurationSearchItem[] {
+        const typeLabel = nls.localize('theia/ai/core/modelAliasesConfiguration/aliasTypeLabel', 'Model Alias');
+        return this.aliases.map(alias => ({
+            label: alias.id,
+            typeLabel,
+            categoryId: this.id,
+            target: { categoryId: this.id, itemId: alias.id },
+            keywords: alias.description ?? ''
+        } satisfies AiConfigurationSearchItem));
+    }
+}

package/src/browser/ai-configuration/categories/models-configuration-category.spec.ts

@@ -0,0 +1,167 @@
+// *****************************************************************************
+// Copyright (C) 2026 EclipseSource and others.
+//
+// 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 { enableJSDOM } from '@theia/core/lib/browser/test/jsdom';
+let disableJSDOM = enableJSDOM();
+
+import { FrontendApplicationConfigProvider } from '@theia/core/lib/browser/frontend-application-config-provider';
+FrontendApplicationConfigProvider.set({});
+
+import { expect } from 'chai';
+import { AiSettingsControl, AiSettingsRowService } from '@theia/ai-core-ui/lib/browser/ai-configuration/components/ai-settings-row-service';
+import { AiConfigurationCategoryId } from '@theia/ai-core-ui/lib/browser/ai-configuration/ai-configuration-category';
+import { ModelsConfigurationCategory } from './models-configuration-category';
+
+disableJSDOM();
+
+function createCategory(
+    preferenceIds: string[],
+    nonDisplayable: string[] = [],
+    providerLabels: Record<string, string> = {},
+    providerPreferenceIds: string[] = []
+): ModelsConfigurationCategory {
+    const category = new ModelsConfigurationCategory();
+    const hidden = new Set(nonDisplayable);
+    // A preference marks its `ai-features.<segment>.*` block as a provider either by carrying an explicit
+    // provider label or by being listed in `providerPreferenceIds` (mirrors the `aiModelProvider` typeDetail).
+    const providers = new Set([...providerPreferenceIds, ...Object.keys(providerLabels)]);
+    const service: Partial<AiSettingsRowService> = {
+        preferenceIds: () => preferenceIds,
+        isDisplayable: (id: string) => !hidden.has(id),
+        aiFeaturePreferenceIds: () => preferenceIds.filter(id => id.startsWith('ai-features.') && !hidden.has(id)),
+        describe: (id: string) => ({ label: `label:${id}` }),
+        controlFor: (): AiSettingsControl => ({ type: 'string' }),
+        modelProviderLabel: (id: string) => providerLabels[id],
+        isModelProviderPreference: (id: string) => providers.has(id)
+    };
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    (category as any).settingsRowService = service;
+    return category;
+}
+
+describe('ModelsConfigurationCategory', () => {
+
+    before(() => disableJSDOM = enableJSDOM());
+    after(() => disableJSDOM());
+
+    it('declares the models collection metadata', () => {
+        const category = createCategory([]);
+        expect(category.id).to.equal(AiConfigurationCategoryId.MODELS);
+        expect(category.kind).to.equal('collection');
+        expect(category.renderer).to.equal(category);
+    });
+
+    it('groups model settings and one section per discovered provider, ignoring other categories', () => {
+        const category = createCategory([
+            'ai-features.modelSettings.requestSettings',
+            'ai-features.reasoning.defaults',
+            'ai-features.anthropic.AnthropicApiKey',
+            'ai-features.anthropic.AnthropicModels',
+            'ai-features.google.apiKey',
+            // must be ignored: owned by other categories / unrelated
+            'ai-features.chat.pinChatAgent',
+            'ai-features.AiEnable.enableAI',
+            'editor.fontSize'
+        ], [], {}, [
+            // one preference per block declares the provider marker; the whole segment becomes a provider block
+            'ai-features.anthropic.AnthropicApiKey',
+            'ai-features.google.apiKey'
+        ]);
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const sections = (category as any).getSections() as Array<{ id: string; preferenceIds: string[] }>;
+        expect(sections.map(s => s.id)).to.deep.equal(['model-settings', 'anthropic', 'google']);
+        expect(sections[0].preferenceIds).to.have.members(['ai-features.modelSettings.requestSettings', 'ai-features.reasoning.defaults']);
+        expect(sections[1].preferenceIds).to.deep.equal(['ai-features.anthropic.AnthropicApiKey', 'ai-features.anthropic.AnthropicModels']);
+        expect(sections[2].preferenceIds).to.deep.equal(['ai-features.google.apiKey']);
+    });
+
+    it('does not treat the agent settings store as a provider', () => {
+        const category = createCategory([
+            'ai-features.anthropic.AnthropicApiKey',
+            // agent settings: the hidden backing store and its value-less redirect placeholder
+            'ai-features.agentSettings',
+            'ai-features.agentSettings.details'
+        ], ['ai-features.agentSettings', 'ai-features.agentSettings.details'], {}, ['ai-features.anthropic.AnthropicApiKey']);
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const sections = (category as any).getSections() as Array<{ id: string; preferenceIds: string[] }>;
+        expect(sections.map(s => s.id)).to.deep.equal(['anthropic']);
+    });
+
+    it('does not treat an unmarked feature area as a provider (it falls through to the General catch-all)', () => {
+        const category = createCategory([
+            'ai-features.anthropic.AnthropicApiKey',
+            // a feature area that never declares the provider marker must NOT appear as a provider block
+            'ai-features.telemetry.enabled'
+        ], [], {}, ['ai-features.anthropic.AnthropicApiKey']);
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const sections = (category as any).getSections() as Array<{ id: string; preferenceIds: string[] }>;
+        expect(sections.map(s => s.id)).to.deep.equal(['anthropic']);
+    });
+
+    it('exposes one tree child per provider, excluding the cross-provider model settings', () => {
+        const category = createCategory([
+            'ai-features.modelSettings.requestSettings',
+            'ai-features.huggingFace.apiKey',
+            'ai-features.google.apiKey'
+        ], [], { 'ai-features.huggingFace.apiKey': 'Hugging Face', 'ai-features.google.apiKey': 'Google' });
+        const children = category.getTreeChildren();
+        expect(children.map(c => c.id)).to.deep.equal(['google', 'huggingFace']);
+        // Nodes carry the human-readable provider names the schema declares, not the raw segments,
+        // and are ordered by that visible label ("Google" before "Hugging Face").
+        expect(children.map(c => c.label)).to.deep.equal(['Google', 'Hugging Face']);
+    });
+
+    it('labels a provider with the name declared in its preference schema', () => {
+        const category = createCategory(
+            ['ai-features.huggingFace.apiKey', 'ai-features.huggingFace.models'],
+            [],
+            { 'ai-features.huggingFace.models': 'Hugging Face' }
+        );
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const label = (category as any).getProviderLabel('huggingFace', ['ai-features.huggingFace.apiKey', 'ai-features.huggingFace.models']);
+        // Any preference in the block may carry the declared label.
+        expect(label).to.equal('Hugging Face');
+    });
+
+    it('prettifies the provider segment when the schema declares no name', () => {
+        const category = createCategory([]);
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const label = (id: string): string => (category as any).getProviderLabel(id, [`ai-features.${id}.key`]);
+        expect(label('myCustomProvider')).to.equal('My Custom Provider');
+        expect(label('some-vendor')).to.equal('Some vendor');
+    });
+
+    it('indexes each setting for deep search, navigating provider settings to the provider node', () => {
+        const category = createCategory([
+            'ai-features.modelSettings.requestSettings',
+            'ai-features.anthropic.AnthropicApiKey'
+        ], [], {}, ['ai-features.anthropic.AnthropicApiKey']);
+        const items = category.getSearchItems();
+        expect(items).to.have.lengthOf(2);
+        // Cross-provider model settings navigate to the overview (no itemId).
+        expect(items[0].target).to.deep.equal({
+            categoryId: AiConfigurationCategoryId.MODELS,
+            itemId: undefined,
+            highlight: { rowId: 'ai-features.modelSettings.requestSettings' }
+        });
+        // Provider settings navigate to the provider node.
+        expect(items[1].target).to.deep.equal({
+            categoryId: AiConfigurationCategoryId.MODELS,
+            itemId: 'anthropic',
+            highlight: { rowId: 'ai-features.anthropic.AnthropicApiKey' }
+        });
+    });
+});