@theia/ai-ide 1.76.0-next.7 → 1.76.0

package/src/browser/ai-aware-scm-commit-widget.tsx

@@ -0,0 +1,153 @@
+// *****************************************************************************
+// 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 { inject, injectable, named, postConstruct } from '@theia/core/shared/inversify';
+import * as React from '@theia/core/shared/react';
+import { CommandService, ILogger, nls } from '@theia/core';
+import { codicon } from '@theia/core/lib/browser';
+import { AgentService } from '@theia/ai-core/lib/common';
+import { AIActivationService } from '@theia/ai-core/lib/browser';
+import { ScmCommitWidget } from '@theia/scm/lib/browser/scm-commit-widget';
+import { ScmInput } from '@theia/scm/lib/browser/scm-input';
+import { ScmProvider } from '@theia/scm/lib/browser/scm-provider';
+import { COMMIT_MESSAGE_AGENT_ID } from './commit-message-agent';
+import { CommitMessageCommands } from './commit-message-commands';
+import { CommitMessageRunner } from './commit-message-runner';
+
+/**
+ * Source-control provider id of the VS Code / Theia git extension. The generator runs
+ * `git diff --cached`, so it is git-specific by construction and the overlay is only offered
+ * for that provider rather than for any provider that happens to expose a matching group.
+ */
+const GIT_PROVIDER_ID = 'git';
+
+/** Resource group the git extension uses for staged resources. */
+const STAGED_GROUP_ID = 'index';
+
+/**
+ * Extends the standard SCM commit-message widget with an overlay icon that generates a commit
+ * message from the staged changes. Bound via a DI rebind of {@link ScmCommitWidget} so the SCM
+ * view picks up the AI-aware version transparently.
+ */
+@injectable()
+export class AiAwareScmCommitWidget extends ScmCommitWidget {
+
+    @inject(CommandService)
+    protected readonly commandService: CommandService;
+
+    @inject(CommitMessageRunner)
+    protected readonly commitMessageRunner: CommitMessageRunner;
+
+    @inject(AgentService)
+    protected readonly agentService: AgentService;
+
+    @inject(AIActivationService)
+    protected readonly aiActivationService: AIActivationService;
+
+    @inject(ILogger) @named('ai-ide:AiAwareScmCommitWidget')
+    protected readonly logger: ILogger;
+
+    @postConstruct()
+    protected initAiOverlay(): void {
+        this.toDispose.push(this.commitMessageRunner.onDidChange(() => this.update()));
+        this.toDispose.push(this.agentService.onDidChangeAgents(() => this.update()));
+        this.toDispose.push(this.aiActivationService.onDidChangeActiveStatus(() => this.update()));
+        // `canRun` carries conditions beyond `isActive` (e.g. workspace trust) and is what the
+        // command's `isEnabled` is gated on, so the button's enabled state has to follow it.
+        this.toDispose.push(this.aiActivationService.onDidChangeCanRun(() => this.update()));
+    }
+
+    protected override renderInput(input: ScmInput): React.ReactNode {
+        const baseInput = super.renderInput(input);
+        // The wrapper adds padding to make room for the button, so it must only be rendered when
+        // a button is actually rendered into it. Users with AI off keep the stock SCM input.
+        if (!this.shouldRenderAiButton(input)) {
+            return baseInput;
+        }
+        return <div className='theia-ai-commit-message-input-wrapper'>
+            {baseInput}
+            {this.renderAiOverlay(input)}
+        </div>;
+    }
+
+    protected shouldRenderAiButton(input: ScmInput): boolean {
+        if (!input.visible || !this.aiActivationService.isActive) {
+            return false;
+        }
+        // Without staged changes `git diff --cached` is empty, so the button would have nothing to
+        // work with. A running generation keeps it rendered so it stays cancellable even if the
+        // user unstages everything mid-run.
+        return this.commitMessageRunner.isRunning() || this.hasStagedChanges(this.scmService.selectedRepository?.provider);
+    }
+
+    protected renderAiOverlay(input: ScmInput): React.ReactNode {
+        const running = this.commitMessageRunner.isRunning();
+        const agentEnabled = this.agentService.isEnabled(COMMIT_MESSAGE_AGENT_ID);
+        // Mirrors `CommitMessageCommandContribution.isEnabled` as wrapped by
+        // `AICommandHandlerFactory`; a divergence would render an enabled button whose click ends
+        // in a `NO_ACTIVE_HANDLER` error. Cancelling is always allowed, so that the spinner keeps
+        // working while the git extension has the input disabled during a commit.
+        const disabled = !running && (!this.aiActivationService.canRun || !agentEnabled || !input.enabled);
+
+        let title: string;
+        if (running) {
+            title = nls.localize('theia/ai-ide/commit-message/cancel-tooltip', 'Cancel commit-message generation');
+        } else if (!agentEnabled) {
+            title = nls.localize(
+                'theia/ai-ide/commit-message/agent-disabled-tooltip',
+                'The Commit Message agent is disabled. Enable it in the AI Configuration view.'
+            );
+        } else {
+            title = nls.localize(
+                'theia/ai-ide/commit-message/staged-tooltip',
+                'Generate commit message from staged changes'
+            );
+        }
+        const iconClass = running ? `${codicon('loading')} codicon-modifier-spin` : codicon('sparkle');
+
+        return <div className='theia-ai-commit-message-overlay'>
+            <button
+                className='theia-ai-commit-message-icon'
+                type='button'
+                title={title}
+                aria-label={title}
+                disabled={disabled}
+                onClick={this.onAiButtonClick}>
+                <span className={iconClass} />
+            </button>
+        </div>;
+    }
+
+    protected onAiButtonClick = () => {
+        // Cancelling never goes through the command: its `isEnabled` requires an enabled commit
+        // input and a runnable AI, either of which may have flipped off since the run started.
+        if (this.commitMessageRunner.isRunning()) {
+            this.commitMessageRunner.cancel();
+            return;
+        }
+        this.commandService.executeCommand(CommitMessageCommands.GENERATE_FROM_STAGED.id).catch(error =>
+            this.logger.error('Failed to execute AI commit-message command', error)
+        );
+    };
+
+    protected hasStagedChanges(provider: ScmProvider | undefined): boolean {
+        if (provider?.id !== GIT_PROVIDER_ID) {
+            return false;
+        }
+        const staged = provider.groups.find(group => group.id === STAGED_GROUP_ID);
+        return !!staged && staged.resources.length > 0;
+    }
+}

package/src/browser/ai-configuration/ai-configuration-detail-widget.spec.ts

@@ -97,7 +97,7 @@ describe('AiConfigurationDetailWidget dispatch', () => {
 });
 
 /**
- * Pins the scrolling arithmetic of {@link AiConfigurationDetailWidget#centerInBody} and, more importantly,
+ * Pins the scrolling arithmetic of {@link AiConfigurationDetailWidget#revealInBody} and, more importantly,
  * that it writes only the scroll container.
  *
  * The predecessor was `element.scrollIntoView({ block: 'center' })`, which also scrolls every scrollable
@@ -106,7 +106,7 @@ describe('AiConfigurationDetailWidget dispatch', () => {
  * `clientHeight` are stubbed; it also does not implement `scrollIntoView`, so reverting to it fails every
  * assertion here (verified by patching the method back).
  */
-describe('AiConfigurationDetailWidget centerInBody', () => {
+describe('AiConfigurationDetailWidget revealInBody', () => {
 
     before(() => disableJSDOM = enableJSDOM());
     after(() => disableJSDOM());
@@ -135,30 +135,30 @@ describe('AiConfigurationDetailWidget centerInBody', () => {
         return { ancestor, body, element };
     }
 
-    it('scrolls the container so the row is vertically centred', () => {
+    it('scrolls the container so the row sits at its top', () => {
         const { body, element } = hierarchy(500);
-        // Row sits 400px below the body's top; centring it in a 400px viewport puts it at (400 - 40) / 2 = 180.
-        widget.centerInBody(body, element);
-        expect(body.scrollTop).to.equal(220);
+        // Row sits 400px below the body's top, less the margin kept above it.
+        widget.revealInBody(body, element);
+        expect(body.scrollTop).to.equal(400 - AiConfigurationDetailWidget.TARGET_ROW_MARGIN);
     });
 
-    it('leaves the scroll position alone when the row is already centred', () => {
-        const { body, element } = hierarchy(280);
-        widget.centerInBody(body, element);
+    it('leaves the scroll position alone when the row is already at the top', () => {
+        const { body, element } = hierarchy(100 + AiConfigurationDetailWidget.TARGET_ROW_MARGIN);
+        widget.revealInBody(body, element);
         expect(body.scrollTop).to.equal(0);
     });
 
-    it('scrolls back up for a row above the centre', () => {
+    it('scrolls back up for a row above the current position', () => {
         const { body, element } = hierarchy(120);
-        // 20px below the body's top, so it has to scroll up by 160 to reach the centre.
+        // 20px below the body's top, so it has to scroll up to put the row at the margin.
         body.scrollTop = 300;
-        widget.centerInBody(body, element);
-        expect(body.scrollTop).to.equal(140);
+        widget.revealInBody(body, element);
+        expect(body.scrollTop).to.equal(300 + 20 - AiConfigurationDetailWidget.TARGET_ROW_MARGIN);
     });
 
     it('never scrolls an ancestor of the container', () => {
         const { ancestor, body, element } = hierarchy(500);
-        widget.centerInBody(body, element);
+        widget.revealInBody(body, element);
         expect(body.scrollTop, 'the container itself should have scrolled').to.not.equal(0);
         expect(ancestor.scrollTop, 'scrolling an ancestor shifts the whole shell').to.equal(0);
     });

package/src/browser/ai-configuration/ai-configuration-detail-widget.tsx

@@ -33,6 +33,8 @@ export class AiConfigurationDetailWidget extends ReactWidget {
 
     /** Frames a pending search highlight waits for its target row to be mounted before it is dropped. */
     static readonly HIGHLIGHT_RETRY_FRAMES = 10;
+    /** Space kept above a row a deep link scrolled to, so that its section header stays visible. */
+    static readonly TARGET_ROW_MARGIN = 24;
 
     @inject(AiConfigurationCategoryRegistry)
     protected readonly registry: AiConfigurationCategoryRegistry;
@@ -201,7 +203,7 @@ export class AiConfigurationDetailWidget extends ReactWidget {
             const element = body.querySelector<HTMLElement>(`[data-ai-config-row-id="${highlight.rowId}"]`);
             if (element) {
                 this.pendingHighlight = undefined;
-                this.centerInBody(body, element);
+                this.revealInBody(body, element);
                 element.classList.add('ai-configuration-row-flash');
                 window.setTimeout(() => element.classList.remove('ai-configuration-row-flash'), 1200);
             } else if (this.pendingHighlightFrames < AiConfigurationDetailWidget.HIGHLIGHT_RETRY_FRAMES) {
@@ -218,20 +220,23 @@ export class AiConfigurationDetailWidget extends ReactWidget {
     }
 
     /**
-     * Vertically centers `element` within `body` by scrolling that container and nothing else.
+     * Scrolls `body`, and nothing else, so that `element` sits at the top of it.
+     *
+     * Top rather than centered: a deep link lands on a page the user has not seen before, and a row in the
+     * middle of it reads as "the page opened somewhere", with the rows above it competing for the attention
+     * the flash is meant to direct. {@link TARGET_ROW_MARGIN} keeps the section header above the row visible.
      *
      * Deliberately not `Element.scrollIntoView`: that scrolls *every* scrollable ancestor to satisfy the
      * requested alignment, and `overflow: hidden` does not prevent programmatic scrolling. When a row cannot
-     * be centered inside the body alone, it therefore nudges the `overflow: hidden` containers above this
-     * widget, which have no scrollbar for the user to scroll back — shifting the whole shell, pushing the menu
+     * be revealed inside the body alone, it therefore nudges the `overflow: hidden` containers above this
+     * widget, which have no scrollbar for the user to scroll back, shifting the whole shell, pushing the menu
      * bar out of view and leaving a gap below the status bar.
      */
-    protected centerInBody(body: HTMLElement, element: HTMLElement): void {
+    protected revealInBody(body: HTMLElement, element: HTMLElement): void {
         const bodyRect = body.getBoundingClientRect();
         const elementRect = element.getBoundingClientRect();
         const current = elementRect.top - bodyRect.top;
-        const centered = (body.clientHeight - elementRect.height) / 2;
         // Assigning `scrollTop` clamps to the scrollable range, so short pages simply do not scroll.
-        body.scrollTop += current - centered;
+        body.scrollTop += current - AiConfigurationDetailWidget.TARGET_ROW_MARGIN;
     }
 }

package/src/browser/ai-configuration/ai-configuration-tree-widget.tsx

@@ -207,11 +207,19 @@ export class AiConfigurationTreeWidget extends TreeWidget {
         return match?.target;
     }
 
+    /**
+     * Selects a node on behalf of something other than a click on it — a deep link, a restored
+     * selection — and reveals what it holds: the category of an item, or the items of a category. A
+     * click needs neither, since the node it selects is already visible, and folding a category away
+     * only to have the next click on it unfold it again would be its own kind of rude.
+     */
     protected applyTreeSelection(node: SelectableTreeNode): void {
         this.updatingSelection = true;
         try {
             if (AiConfigurationItemNode.is(node) && ExpandableTreeNode.is(node.parent) && !node.parent.expanded) {
                 this.model.expandNode(node.parent);
+            } else if (AiConfigurationCategoryNode.is(node) && ExpandableTreeNode.is(node) && !node.expanded) {
+                this.model.expandNode(node);
             }
             this.model.selectNode(node);
         } finally {

package/src/browser/ai-configuration/categories/agent-capabilities-settings.tsx

@@ -25,6 +25,7 @@ import { nls } from '@theia/core';
 import { codicon } from '@theia/core/lib/browser';
 import * as React from '@theia/core/shared/react';
 import { AiConfigurationItemRow } from '@theia/ai-core-ui/lib/browser/ai-configuration/components/ai-configuration-item-row';
+import { AiConfigurationIconButton } from '@theia/ai-core-ui/lib/browser/ai-configuration/components/ai-configuration-primitives';
 import { AiSettingsRowService } from '@theia/ai-core-ui/lib/browser/ai-configuration/components/ai-settings-row-service';
 import { AiToggleSwitch } from '@theia/ai-core-ui/lib/browser/ai-configuration/components/ai-configuration-controls';
 
@@ -44,15 +45,13 @@ const AgentSectionHeader: React.FC<{ title: string; action?: React.ReactNode }>
  * button, so it reads as a Theia reset affordance. Its tooltip says what the section-wide reset does.
  */
 const ResetAllButton: React.FC<{ title: string; disabled?: boolean; onReset: () => void }> = ({ title, disabled, onReset }) => (
-    <button
-        className='ai-variant-action-button ai-agent-section-header-action'
-        onClick={onReset}
-        disabled={disabled}
+    <AiConfigurationIconButton
+        iconClass={codicon('discard')}
         title={title}
-        aria-label={title}
-    >
-        <span aria-hidden='true' className={codicon('discard')}></span>
-    </button>
+        disabled={disabled}
+        className='ai-agent-section-header-action'
+        onClick={onReset}
+    />
 );
 
 export interface AgentCapabilitiesSettingsProps {

package/src/browser/ai-configuration/categories/agent-chips.tsx

@@ -21,7 +21,7 @@ import { getAgentIconClass } from '../agent-icon';
 
 /** A single navigable agent chip (icon + name); shared by the Variables, Skills and Slash Command surfaces. */
 export const AgentChip: React.FC<{ agent: Agent; onOpenAgent: (agentId: string) => void }> = ({ agent, onOpenAgent }) => {
-    const label = nls.localize('theia/ai/ide/variableConfiguration/openAgent', 'Open agent {0}', agent.name);
+    const label = nls.localizeByDefault('Open agent {0}', agent.name);
     return <button
         type='button'
         className='agent-chip'

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

@@ -32,8 +32,8 @@ function alias(id: string, description = ''): LanguageModelAlias {
     return { id, description, defaultModelIds: [] } as unknown as LanguageModelAlias;
 }
 
-function readyModel(id: string): LanguageModel {
-    return { id, status: { status: 'ready' } } as unknown as LanguageModel;
+function readyModel(id: string, released?: number): LanguageModel {
+    return { id, released, status: { status: 'ready' } } as unknown as LanguageModel;
 }
 
 function unreadyModel(id: string): LanguageModel {
@@ -77,6 +77,44 @@ describe('ModelAliasesConfigurationCategory', () => {
         expect(children[2].status?.kind).to.equal('error');
     });
 
+    it('divides the models per provider, newest first, after the default-list entry', () => {
+        const category = createCategory([], new Map());
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        (category as any).languageModels = [
+            readyModel('openai/gpt-5.5', Date.parse('2025-08-01')),
+            readyModel('anthropic/claude-haiku-4-5', Date.parse('2025-10-01')),
+            readyModel('openai/gpt-5.6-sol', Date.parse('2026-02-01')),
+            readyModel('anthropic/claude-opus-5', Date.parse('2026-04-01'))
+        ];
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const options = (category as any).getModelOptions() as Array<{ value?: string; label?: string; separator?: boolean }>;
+        expect(options[0].value).to.equal('');
+        // A rule between the providers rather than a heading: the select draws separators as plain lines.
+        expect(options.slice(1).map(option => option.separator ? '---' : option.value)).to.deep.equal([
+            '---',
+            'anthropic/claude-opus-5',
+            'anthropic/claude-haiku-4-5',
+            '---',
+            'openai/gpt-5.6-sol',
+            'openai/gpt-5.5'
+        ]);
+    });
+
+    it('keeps the provider rules when mapping the options onto the select', () => {
+        const category = createCategory([], new Map());
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const mapped = (category as any).toEnumOptions([
+            { value: 'a', label: 'A', description: 'first' },
+            { separator: true },
+            { value: 'b' }
+        ]) as Array<{ value: string; label: string; title?: string; separator?: boolean }>;
+        // A rule that loses its `separator` becomes a selectable entry with no label that clears the alias.
+        expect(mapped.map(option => option.separator ? '---' : option.value)).to.deep.equal(['a', '---', 'b']);
+        expect(mapped[0].title).to.equal('first');
+        // Without a label of its own, an option falls back to its value rather than rendering empty.
+        expect(mapped[2].label).to.equal('b');
+    });
+
     it('indexes one search item per alias, navigating to the item', () => {
         const category = createCategory([alias('default/code', 'Coding alias')], new Map());
         const items = category.getSearchItems();

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

@@ -14,7 +14,7 @@
 // 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 { AgentService, AISettingsService, groupModelsByProvider, 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';
@@ -35,7 +35,7 @@ import {
 } 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 { AiEnumOption, 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). */
@@ -214,28 +214,49 @@ export class ModelAliasesConfigurationCategory extends CollectionCategoryRendere
                 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 }))}
+                options={this.toEnumOptions(options)}
                 onCommit={value => this.setSelectedModel(alias, value)}
             />
         </AiConfigurationSection>;
     }
 
+    /**
+     * Maps the options onto what {@link AiEnumSelect} takes. The per-provider rules have to survive the
+     * mapping: dropping `separator` turns each of them into a selectable entry with no label that
+     * clears the alias when picked.
+     */
+    protected toEnumOptions(options: SelectOption[]): AiEnumOption[] {
+        return options.map(option => ({
+            value: String(option.value ?? ''),
+            label: option.label ?? String(option.value ?? ''),
+            title: option.description,
+            separator: option.separator
+        }));
+    }
+
     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
-            });
+        // Divided per provider, newest first inside each group. An alias names a concrete model, which
+        // includes the older and release-pinned ones, so the whole catalogue is offered here.
+        for (const { models } of groupModelsByProvider(this.languageModels)) {
+            options.push({ separator: true });
+            options.push(...models.map(model => this.toModelOption(model)));
         }
         return options;
     }
 
+    protected toModelOption(model: LanguageModel): SelectOption {
+        const ready = model.status.status === 'ready';
+        return {
+            value: model.id,
+            label: `${model.name ?? model.id} ${ready ? '✓' : '✗'}`,
+            description: !ready ? model.status.message : undefined
+        };
+    }
+
     protected setSelectedModel(alias: LanguageModelAlias, value: string | undefined): void {
         const selectedModelId = value ? value : undefined;
         this.languageModelAliasRegistry.ready.then(() => this.languageModelAliasRegistry.addAlias({ ...alias, selectedModelId }));

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

@@ -23,6 +23,8 @@ 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 { ModelDiscoveryStatusService } from '@theia/ai-core/lib/browser';
+import { ModelDiscoveryStatus } from '@theia/ai-core/lib/common/model-discovery-status';
 import { ModelsConfigurationCategory } from './models-configuration-category';
 
 disableJSDOM();
@@ -69,7 +71,7 @@ describe('ModelsConfigurationCategory', () => {
             'ai-features.modelSettings.requestSettings',
             'ai-features.reasoning.defaults',
             'ai-features.anthropic.AnthropicApiKey',
-            'ai-features.anthropic.AnthropicModels',
+            'ai-features.anthropic.serverSideCompaction',
             'ai-features.google.apiKey',
             // must be ignored: owned by other categories / unrelated
             'ai-features.chat.pinChatAgent',
@@ -84,7 +86,7 @@ describe('ModelsConfigurationCategory', () => {
         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[1].preferenceIds).to.deep.equal(['ai-features.anthropic.AnthropicApiKey', 'ai-features.anthropic.serverSideCompaction']);
         expect(sections[2].preferenceIds).to.deep.equal(['ai-features.google.apiKey']);
     });
 
@@ -164,4 +166,47 @@ describe('ModelsConfigurationCategory', () => {
             highlight: { rowId: 'ai-features.anthropic.AnthropicApiKey' }
         });
     });
+
+    describe('model discovery section', () => {
+
+        function withDiscovery(statuses: ModelDiscoveryStatus[], modelIds: string[]): ModelsConfigurationCategory {
+            const category = createCategory([]);
+            const service: Partial<ModelDiscoveryStatusService> = {
+                getStatus: (providerId: string) => statuses.find(status => status.providerId === providerId)
+            };
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            (category as any).discoveryStatus = service;
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            (category as any).models = modelIds.map(id => ({ id }));
+            return category;
+        }
+
+        function discoveredModelIds(category: ModelsConfigurationCategory, providerId: string): string[] | undefined {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const rendered = (category as any).renderModelDiscovery(providerId) as
+                { props: { models: { id: string }[] } } | undefined;
+            return rendered && rendered.props.models.map(model => model.id);
+        }
+
+        it('renders nothing for a provider that does not participate in discovery', () => {
+            const category = withDiscovery([], ['anthropic/claude-opus-5']);
+            expect(discoveredModelIds(category, 'anthropic')).to.equal(undefined);
+        });
+
+        it('lists the provider\'s own models, keyed by the provider id', () => {
+            const category = withDiscovery(
+                [{ providerId: 'anthropic', label: 'Anthropic', state: 'ready' }],
+                ['anthropic/claude-opus-5', 'google/gemini-3.1-pro', 'anthropic-custom/foo']
+            );
+            expect(discoveredModelIds(category, 'anthropic')).to.deep.equal(['anthropic/claude-opus-5']);
+        });
+
+        it('honours a model-id prefix that differs from the provider id', () => {
+            const category = withDiscovery(
+                [{ providerId: 'openAiOfficial', label: 'OpenAI', modelIdPrefix: 'openai', state: 'ready' }],
+                ['openai/gpt-5.5', 'openAiOfficial/gpt-5.5', 'openai-custom/local']
+            );
+            expect(discoveredModelIds(category, 'openAiOfficial')).to.deep.equal(['openai/gpt-5.5']);
+        });
+    });
 });

package/src/browser/ai-configuration/categories/models-configuration-category.tsx

@@ -14,7 +14,7 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 
-import { Emitter, Event, nls } from '@theia/core';
+import { CommandService, Emitter, Event, nls } from '@theia/core';
 import { codicon } from '@theia/core/lib/browser';
 import { DisposableCollection } from '@theia/core/lib/common';
 import { inject, injectable, postConstruct } from '@theia/core/shared/inversify';
@@ -32,6 +32,9 @@ import { AiSettingsRowService } from '@theia/ai-core-ui/lib/browser/ai-configura
 import { AiConfigurationSection } from '@theia/ai-core-ui/lib/browser/ai-configuration/components/ai-configuration-primitives';
 import { CollectionCategoryRenderer } from '@theia/ai-core-ui/lib/browser/ai-configuration/renderers/collection-category-renderer';
 import { AiSettingsRow } from '@theia/ai-core-ui/lib/browser/ai-configuration/components/ai-settings-row';
+import { LanguageModel, LanguageModelRegistry } from '@theia/ai-core/lib/common';
+import { FavoriteModelsService, ModelDiscoveryStatusService } from '@theia/ai-core/lib/browser';
+import { ProviderModelDiscoverySection } from './provider-model-discovery-section';
 
 /** Prefix shared by every AI preference. */
 const AI_FEATURES_PREFIX = 'ai-features.';
@@ -73,10 +76,25 @@ export class ModelsConfigurationCategory extends CollectionCategoryRenderer impl
     @inject(AiSettingsRowService)
     protected readonly settingsRowService: AiSettingsRowService;
 
+    @inject(ModelDiscoveryStatusService)
+    protected readonly discoveryStatus: ModelDiscoveryStatusService;
+
+    @inject(FavoriteModelsService)
+    protected readonly favoriteModels: FavoriteModelsService;
+
+    @inject(CommandService)
+    protected readonly commandService: CommandService;
+
+    @inject(LanguageModelRegistry)
+    protected readonly languageModelRegistry: LanguageModelRegistry;
+
     protected readonly onDidChangeEmitter = new Emitter<void>();
     readonly onDidChange: Event<void> = this.onDidChangeEmitter.event;
     protected readonly toDispose = new DisposableCollection(this.onDidChangeEmitter);
 
+    /** Registered models, kept in sync so the provider detail can list them synchronously while rendering. */
+    protected models: LanguageModel[] = [];
+
     get renderer(): this {
         return this;
     }
@@ -96,6 +114,14 @@ export class ModelsConfigurationCategory extends CollectionCategoryRenderer impl
     @postConstruct()
     protected init(): void {
         this.toDispose.push(this.settingsRowService.onPreferenceChanged(() => this.onDidChangeEmitter.fire()));
+        this.toDispose.push(this.discoveryStatus.onDidChange(() => this.onDidChangeEmitter.fire()));
+        this.toDispose.push(this.languageModelRegistry.onChange(() => this.updateModels()));
+        this.updateModels();
+    }
+
+    protected async updateModels(): Promise<void> {
+        this.models = await this.languageModelRegistry.getLanguageModels();
+        this.onDidChangeEmitter.fire();
     }
 
     dispose(): void {
@@ -130,15 +156,36 @@ export class ModelsConfigurationCategory extends CollectionCategoryRenderer impl
         </AiConfigurationSection>;
     }
 
-    /** Provider detail (node selected): that provider's settings. */
+    /** Provider detail (node selected): that provider's settings, followed by its model discovery. */
     protected renderItemSections(item: AiConfigurationTreeItem, ctx: AiConfigurationRenderContext): React.ReactNode {
         const section = this.getProviderSections().find(candidate => candidate.id === item.id);
         if (!section) {
             return undefined;
         }
-        return <AiConfigurationSection title={nls.localizeByDefault('Settings')}>
-            {section.preferenceIds.map(preferenceId => this.renderPreferenceRow(ctx, preferenceId))}
-        </AiConfigurationSection>;
+        return <>
+            <AiConfigurationSection title={nls.localizeByDefault('Settings')}>
+                {section.preferenceIds.map(preferenceId => this.renderPreferenceRow(ctx, preferenceId))}
+            </AiConfigurationSection>
+            {this.renderModelDiscovery(item.id)}
+        </>;
+    }
+
+    /** Only providers that participate in dynamic model discovery contribute this section. */
+    protected renderModelDiscovery(providerId: string): React.ReactNode {
+        const status = this.discoveryStatus.getStatus(providerId);
+        if (!status) {
+            return undefined;
+        }
+        // A provider's registered model ids may carry a prefix that differs from its preference segment
+        // (e.g. the `openAiOfficial` block registers `openai/…` models).
+        const prefix = `${status.modelIdPrefix ?? providerId}/`;
+        return <ProviderModelDiscoverySection
+            status={status}
+            models={this.models.filter(model => model.id.startsWith(prefix))}
+            favorites={this.favoriteModels}
+            onRefresh={() => this.discoveryStatus.refresh(providerId)}
+            onAction={action => this.commandService.executeCommand(action.commandId, ...(action.args ?? []))}
+        />;
     }
 
     protected renderPreferenceRow(ctx: AiConfigurationRenderContext, preferenceId: string): React.ReactNode {