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

package/src/browser/ai-configuration/language-model-renderer.spec.ts

@@ -0,0 +1,100 @@
+// *****************************************************************************
+// 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 * as React from '@theia/core/shared/react';
+import { flushSync } from '@theia/core/shared/react-dom';
+import { createRoot } from '@theia/core/shared/react-dom/client';
+import { ReasoningSupport } from '@theia/ai-core/lib/common';
+import { AiSettingsRowService } from '@theia/ai-core-ui/lib/browser/ai-configuration/components/ai-settings-row-service';
+import { ReasoningRow } from './language-model-renderer';
+
+disableJSDOM();
+
+describe('ReasoningRow', () => {
+
+    before(() => disableJSDOM = enableJSDOM());
+    after(() => disableJSDOM());
+
+    const support: ReasoningSupport = { supportedLevels: ['off', 'low', 'high'], defaultLevel: 'low' };
+
+    function render(props: Partial<React.ComponentProps<typeof ReasoningRow>>): { container: HTMLElement; dispose: () => void } {
+        const container = document.createElement('div');
+        document.body.appendChild(container);
+        const root = createRoot(container);
+        flushSync(() => root.render(React.createElement(ReasoningRow, {
+            support,
+            inheritedLevel: 'low',
+            onSelect: () => { },
+            onReset: () => { },
+            settingsRowService: { openResetMenu: () => { } } as unknown as AiSettingsRowService,
+            ...props
+        })));
+        return { container, dispose: () => { flushSync(() => root.unmount()); container.remove(); } };
+    }
+
+    it('marks the select with the effective level, which is what draws the shared lightbulb glyph', () => {
+        const stored = render({ savedLevel: 'high' });
+        try {
+            const select = stored.container.querySelector('.theia-ReasoningLevelSelector');
+            expect(select?.classList.contains('reasoning-level-high')).to.equal(true);
+        } finally {
+            stored.dispose();
+        }
+
+        // Nothing stored: the row shows the inherited level, so the glyph matches what the model will do.
+        const inherited = render({ savedLevel: undefined, inheritedLevel: 'off' });
+        try {
+            const select = inherited.container.querySelector('.theia-ReasoningLevelSelector');
+            expect(select?.classList.contains('reasoning-level-off')).to.equal(true);
+        } finally {
+            inherited.dispose();
+        }
+    });
+
+    it('offers a reset only once a level is stored for the agent', () => {
+        const stored = render({ savedLevel: 'high' });
+        try {
+            expect(Boolean(stored.container.querySelector('.ai-settings-row-gear'))).to.equal(true);
+            expect(Boolean(stored.container.querySelector('.ai-settings-row.modified'))).to.equal(true);
+        } finally {
+            stored.dispose();
+        }
+
+        const inherited = render({ savedLevel: undefined });
+        try {
+            expect(Boolean(inherited.container.querySelector('.ai-settings-row-gear'))).to.equal(false);
+            expect(Boolean(inherited.container.querySelector('.ai-settings-row.modified'))).to.equal(false);
+        } finally {
+            inherited.dispose();
+        }
+    });
+
+    it('names the inherited level while nothing is stored, so the effective value is not a guess', () => {
+        const inherited = render({ savedLevel: undefined, inheritedLevel: 'high' });
+        try {
+            expect(inherited.container.textContent).to.include('High');
+        } finally {
+            inherited.dispose();
+        }
+    });
+});

package/src/browser/ai-configuration/language-model-renderer.tsx

@@ -14,10 +14,24 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 import * as React from '@theia/core/shared/react';
-import { Agent, AISettingsService, FrontendLanguageModelRegistry, LanguageModel, LanguageModelRequirement } from '@theia/ai-core/lib/common';
+import {
+    Agent,
+    AISettingsService,
+    FrontendLanguageModelRegistry,
+    LanguageModel,
+    LanguageModelRequirement,
+    PREFERENCE_NAME_REASONING,
+    ReasoningLevel,
+    ReasoningPreferenceEntry,
+    ReasoningSupport
+} from '@theia/ai-core/lib/common';
+import { mergeReasoningSettings } from '@theia/ai-core/lib/browser/frontend-language-model-service';
 import { LanguageModelAlias } from '@theia/ai-core/lib/common/language-model-alias';
 import { Mutable } from '@theia/core';
 import { nls } from '@theia/core/lib/common/nls';
+import { SelectComponent, SelectOption } from '@theia/core/lib/browser/widgets/select-component';
+import { AiConfigurationSettingRow } from '@theia/ai-core-ui/lib/browser/ai-configuration/components/ai-configuration-setting-row';
+import { AiSettingsRowService } from '@theia/ai-core-ui/lib/browser/ai-configuration/components/ai-settings-row-service';
 
 export interface LanguageModelSettingsProps {
     agent: Agent;
@@ -25,37 +39,130 @@ export interface LanguageModelSettingsProps {
     aiSettingsService: AISettingsService;
     languageModelRegistry: FrontendLanguageModelRegistry;
     languageModelAliases: LanguageModelAlias[];
+    /** Backs each purpose row's gear menu (its "Reset Setting" drops that purpose's override). */
+    settingsRowService: AiSettingsRowService;
 }
 
-export const LanguageModelRenderer: React.FC<LanguageModelSettingsProps> = (
-    { agent, languageModels, aiSettingsService, languageModelRegistry, languageModelAliases: aliases }) => {
+/**
+ * The model/alias picker for a single requirement, backed by the shared {@link SelectComponent}.
+ * Extracted so its `onChange` can be a stable, purpose-bound callback (rather than an inline closure)
+ * per the React guideline.
+ */
+const ModelSelect: React.FC<{
+    id: string;
+    purpose: string;
+    value: string | undefined;
+    options: SelectOption[];
+    onSelect: (purpose: string, identifier: string) => void;
+}> = ({ id, purpose, value, options, onSelect }) => {
+    const handleChange = React.useCallback((option: SelectOption): void => {
+        onSelect(purpose, option.value ?? '');
+    }, [onSelect, purpose]);
+    return <SelectComponent
+        id={id}
+        className='ai-config-select ai-configuration-value-row-value'
+        options={options}
+        defaultValue={value}
+        onChange={handleChange}
+    />;
+};
 
-    const findLanguageModelRequirement = async (purpose: string): Promise<LanguageModelRequirement | undefined> => {
-        const requirementSetting = await aiSettingsService.getAgentSettings(agent.id);
-        return requirementSetting?.languageModelRequirements?.find(e => e.purpose === purpose);
-    };
+/** Same wording as the chat input's selector, so a level reads identically wherever it is set. */
+const reasoningLevelLabel = (level: ReasoningLevel): string => {
+    switch (level) {
+        case 'off': return nls.localizeByDefault('Off');
+        case 'minimal': return nls.localizeByDefault('Minimal');
+        case 'low': return nls.localizeByDefault('Low');
+        case 'medium': return nls.localizeByDefault('Medium');
+        case 'high': return nls.localizeByDefault('High');
+        case 'auto': return nls.localizeByDefault('Auto');
+    }
+};
+
+/**
+ * The agent's persisted reasoning level, shown right below its models because that is the model
+ * capability it depends on. The chat input's selector writes this same per-agent setting, so without this
+ * row there is no way to see what it stored, change it outside a chat, or clear it again.
+ *
+ * Shown only while the resolved model declares reasoning support, matching the chat input, which hides its
+ * selector in that case. The select carries `theia-ReasoningLevelSelector` so it shows the same per-level
+ * lightbulb glyphs as the chat input.
+ *
+ * Exported for tests: the glyph class it builds is the contract with `ai-chat-ui`'s shared CSS.
+ */
+export const ReasoningRow: React.FC<{
+    support: ReasoningSupport;
+    /** Level stored for this agent; `undefined` means the level is inherited. */
+    savedLevel?: ReasoningLevel;
+    /** Level that applies when nothing is stored: the matching preference default, else the model's. */
+    inheritedLevel: ReasoningLevel;
+    onSelect: (level: ReasoningLevel) => void;
+    onReset: () => void;
+    settingsRowService: AiSettingsRowService;
+}> = ({ support, savedLevel, inheritedLevel, onSelect, onReset, settingsRowService }) => {
+    const options = React.useMemo<SelectOption[]>(
+        () => support.supportedLevels.map(level => ({ value: level, label: reasoningLevelLabel(level) })),
+        [support]
+    );
+    const handleChange = React.useCallback((option: SelectOption): void => {
+        if (option.value) {
+            onSelect(option.value as ReasoningLevel);
+        }
+    }, [onSelect]);
+    const effectiveLevel = savedLevel ?? inheritedLevel;
+    return <AiConfigurationSettingRow
+        title={nls.localizeByDefault('Reasoning')}
+        description={savedLevel
+            ? nls.localize('theia/ai/core/languageModelRenderer/reasoningStored',
+                'Reasoning effort this agent asks the model for. Set here or by the chat input\'s selector, which writes the same setting.')
+            : nls.localize('theia/ai/core/languageModelRenderer/reasoningInherited',
+                'Reasoning effort this agent asks the model for. Not set, so "{0}" applies, from the reasoning defaults preference or the model.',
+                reasoningLevelLabel(inheritedLevel))}
+        modified={savedLevel !== undefined}
+        below={<SelectComponent
+            className={`ai-config-select ai-configuration-value-row-value theia-ReasoningLevelSelector reasoning-level-${effectiveLevel}`}
+            options={options}
+            defaultValue={effectiveLevel}
+            onChange={handleChange}
+        />}
+        onOpenMenu={savedLevel !== undefined ? gear => settingsRowService.openResetMenu(gear, onReset) : undefined}
+    />;
+};
+
+export const LanguageModelRenderer: React.FC<LanguageModelSettingsProps> = (
+    { agent, languageModels, aiSettingsService, languageModelRegistry, languageModelAliases: aliases, settingsRowService }) => {
 
     const [lmRequirementMap, setLmRequirementMap] = React.useState<Record<string, LanguageModelRequirement>>({});
+    const [overriddenPurposes, setOverriddenPurposes] = React.useState<ReadonlySet<string>>(new Set());
     const [resolvedAliasModels, setResolvedAliasModels] = React.useState<Record<string, LanguageModel | undefined>>({});
+    /** Level stored for this agent, as the chat input's selector persists it; `undefined` means inherited. */
+    const [savedReasoningLevel, setSavedReasoningLevel] = React.useState<ReasoningLevel | undefined>(undefined);
 
-    React.useEffect(() => {
-        const computeLmRequirementMap = async () => {
-            const map = await agent.languageModelRequirements.reduce(async (accPromise, curr) => {
-                const acc = await accPromise;
-                // take the agents requirements and override them with the user settings if present
-                const lmRequirement = await findLanguageModelRequirement(curr.purpose) ?? curr;
-                // if no llm is selected through the identifier, see what would be the default
-                if (!lmRequirement.identifier) {
-                    const llm = await languageModelRegistry.selectLanguageModel({ agent: agent.id, ...lmRequirement });
-                    (lmRequirement as Mutable<LanguageModelRequirement>).identifier = llm?.id;
-                }
-                acc[curr.purpose] = lmRequirement;
-                return acc;
-            }, Promise.resolve({} as Record<string, LanguageModelRequirement>));
-            setLmRequirementMap(map);
-        };
-        computeLmRequirementMap();
-    }, []);
+    // Merge the agent's declared requirements with the user's per-purpose overrides, resolving a default model
+    // where none is selected, and track which purposes the user has explicitly overridden (for the reset action).
+    const loadRequirements = React.useCallback(async (): Promise<void> => {
+        const settings = await aiSettingsService.getAgentSettings(agent.id);
+        const userRequirements = settings?.languageModelRequirements ?? [];
+        const overrides = new Set<string>();
+        const map: Record<string, LanguageModelRequirement> = {};
+        for (const declared of agent.languageModelRequirements) {
+            const userRequirement = userRequirements.find(e => e.purpose === declared.purpose);
+            if (userRequirement) {
+                overrides.add(declared.purpose);
+            }
+            const lmRequirement = userRequirement ?? declared;
+            if (!lmRequirement.identifier) {
+                const llm = await languageModelRegistry.selectLanguageModel({ agent: agent.id, ...lmRequirement });
+                (lmRequirement as Mutable<LanguageModelRequirement>).identifier = llm?.id;
+            }
+            map[declared.purpose] = lmRequirement;
+        }
+        setLmRequirementMap(map);
+        setOverriddenPurposes(overrides);
+        setSavedReasoningLevel(settings?.reasoning?.level);
+    }, [agent, aiSettingsService, languageModelRegistry]);
+
+    React.useEffect(() => { loadRequirements(); }, [loadRequirements]);
 
     // Effect to resolve alias to model whenever requirements.identifier or aliases change
     React.useEffect(() => {
@@ -72,89 +179,126 @@ export const LanguageModelRenderer: React.FC<LanguageModelSettingsProps> = (
         resolveAliases();
     }, [lmRequirementMap, aliases]);
 
-    const onSelectedModelChange = (purpose: string, event: React.ChangeEvent<HTMLSelectElement>): void => {
-        const newLmRequirementMap = { ...lmRequirementMap, [purpose]: { purpose, identifier: event.target.value } };
+    /**
+     * The model behind the agent's requirements that declares reasoning support, and the id it is known by.
+     * Mirrors the chat input, which takes the first supporting model it resolves for the receiving agent.
+     */
+    const reasoningModel = React.useMemo<LanguageModel | undefined>(() => {
+        for (const requirement of Object.values(lmRequirementMap)) {
+            const identifier = requirement.identifier;
+            if (!identifier) {
+                continue;
+            }
+            const model = aliases.some(alias => alias.id === identifier)
+                ? resolvedAliasModels[identifier]
+                : languageModels?.find(candidate => candidate.id === identifier);
+            if (model?.reasoningSupport) {
+                return model;
+            }
+        }
+        return undefined;
+    }, [lmRequirementMap, resolvedAliasModels, aliases, languageModels]);
+
+    /** What applies while the agent stores no level: the matching reasoning default, else the model's own. */
+    const inheritedReasoningLevel = React.useMemo<ReasoningLevel>(() => {
+        const support = reasoningModel?.reasoningSupport;
+        if (!support) {
+            return 'off';
+        }
+        const entries = settingsRowService.inspect(PREFERENCE_NAME_REASONING, 'user').value as ReasoningPreferenceEntry[] | undefined;
+        const [providerId, modelId] = (reasoningModel?.id ?? '').split('/');
+        const fromPreference = entries?.length
+            ? mergeReasoningSettings(entries, modelId, providerId, agent.id)?.reasoning?.level
+            : undefined;
+        return fromPreference ?? support.defaultLevel ?? support.supportedLevels[0] ?? 'off';
+    }, [reasoningModel, settingsRowService, agent.id]);
+
+    const onReasoningChange = React.useCallback(async (level: ReasoningLevel): Promise<void> => {
+        await aiSettingsService.updateAgentSettings(agent.id, { reasoning: { level } });
+        setSavedReasoningLevel(level);
+    }, [aiSettingsService, agent.id]);
+
+    // Drop the stored level so the preference default (or the model's) applies again.
+    const onResetReasoning = React.useCallback(async (): Promise<void> => {
+        await aiSettingsService.updateAgentSettings(agent.id, { reasoning: undefined });
+        setSavedReasoningLevel(undefined);
+    }, [aiSettingsService, agent.id]);
+
+    const onSelectedModelChange = React.useCallback((purpose: string, identifier: string): void => {
+        const newLmRequirementMap = { ...lmRequirementMap, [purpose]: { purpose, identifier } };
         aiSettingsService.updateAgentSettings(agent.id, { languageModelRequirements: Object.values(newLmRequirementMap) });
         setLmRequirementMap(newLmRequirementMap);
-    };
+        setOverriddenPurposes(previous => new Set(previous).add(purpose));
+    }, [lmRequirementMap, aiSettingsService, agent.id]);
+
+    // Reset a purpose: drop the user override so it falls back to the agent's declared requirement.
+    const onResetPurpose = React.useCallback(async (purpose: string): Promise<void> => {
+        const settings = await aiSettingsService.getAgentSettings(agent.id);
+        const remaining = (settings?.languageModelRequirements ?? []).filter(requirement => requirement.purpose !== purpose);
+        await aiSettingsService.updateAgentSettings(agent.id, { languageModelRequirements: remaining });
+        await loadRequirements();
+    }, [aiSettingsService, agent.id, loadRequirements]);
+
+    // The empty entry preserves the "no selection" choice; aliases are listed first, then language models.
+    const modelSelectOptions = React.useMemo<SelectOption[]>(() => {
+        const options: SelectOption[] = [{ value: '', label: '' }];
+        aliases?.slice().sort((a, b) => a.id.localeCompare(b.id)).forEach(alias => {
+            options.push({
+                value: alias.id,
+                label: nls.localize('theia/ai/core/languageModelRenderer/alias', '[alias] {0}', alias.id)
+            });
+        });
+        languageModels?.slice().sort((a, b) => (a.name ?? a.id).localeCompare(b.name ?? b.id)).forEach(model => {
+            const isNotReady = model.status.status !== 'ready';
+            options.push({
+                value: model.id,
+                label: `${model.name ?? model.id} ${isNotReady ? '✗' : '✓'}`,
+                description: isNotReady && model.status.message ? model.status.message : undefined
+            });
+        });
+        return options;
+    }, [aliases, languageModels]);
 
     return <div className='language-model-container'>
         {lmRequirementMap && Object.keys(lmRequirementMap).length > 0 ? (
             <div className="settings-section-subcategory-title ai-settings-section-subcategory-title">
-                {nls.localize('theia/ai/core/agentConfiguration/llmRequirements', 'LLM Requirements')}
+                {nls.localizeByDefault('Language Models')}
             </div>
         ) : undefined}
-        {Object.values(lmRequirementMap).map((requirement, index) => {
-            const isAlias = requirement.identifier && aliases.some(a => a.id === requirement.identifier);
-            const resolvedModel = isAlias ? resolvedAliasModels[requirement.identifier] : undefined;
-            return (
-                <div key={index} className="ai-llm-requirement-item">
-                    <div className="ai-configuration-value-row">
-                        <span className="ai-configuration-value-row-label">{nls.localize('theia/ai/core/languageModelRenderer/purpose', 'Purpose')}:</span>
-                        <span className="ai-configuration-value-row-value">{requirement.purpose}</span>
-                    </div>
-                    <div className="ai-configuration-value-row">
-                        <label
-                            className="ai-configuration-value-row-label"
-                            style={{ lineHeight: '1.4' }}
-                            htmlFor={`model-select-${agent.id}-${requirement.purpose}`}>
-                            {nls.localize('theia/ai/core/languageModelRenderer/languageModel', 'Language Model')}:
-                        </label>
-                        <select
-                            className="theia-select ai-configuration-value-row-value"
-                            id={`model-select-${agent.id}-${requirement.purpose}`}
-                            style={{ maxWidth: '400px' }}
-                            value={requirement.identifier}
-                            onChange={event => onSelectedModelChange(requirement.purpose, event)}
-                        >
-                            <option value=""></option>
-                            {/* Aliases first, then languange models */}
-                            {aliases?.sort((a, b) => a.id.localeCompare(b.id)).map(alias => (
-                                <option key={`alias/${alias.id}`} value={alias.id} className='ai-language-model-item-ready'>
-                                    {nls.localize('theia/ai/core/languageModelRenderer/alias', '[alias] {0}', alias.id)}
-                                </option>
-                            ))}
-                            {languageModels?.sort((a, b) => (a.name ?? a.id).localeCompare(b.name ?? b.id)).map(model => {
-                                const isNotReady = model.status.status !== 'ready';
-                                return (
-                                    <option
-                                        key={model.id}
-                                        value={model.id}
-                                        className={isNotReady ? 'ai-language-model-item-not-ready' : 'ai-language-model-item-ready'}
-                                        title={isNotReady && model.status.message ? model.status.message : undefined}
-                                    >
-                                        {model.name ?? model.id} {isNotReady ? '✗' : '✓'}
-                                    </option>
-                                );
-                            })}
-                        </select>
-                    </div>
-                    {/* If alias is selected, show what it currently evaluates to */}
-                    {isAlias && (
-                        <div className="ai-configuration-value-row">
-                            <span className="ai-configuration-value-row-label">{nls.localize('theia/ai/core/modelAliasesConfiguration/evaluatesTo', 'Evaluates to')}:</span>
-                            {resolvedModel ? (
-                                <span className="ai-configuration-value-row-value">
-                                    {resolvedModel.name ?? resolvedModel.id}
-                                    {resolvedModel.status.status === 'ready' ? (
-                                        <span className="ai-model-status-ready"
-                                            title={nls.localize('theia/ai/core/modelAliasesConfiguration/modelReadyTooltip', 'Ready')}>✓</span>
-                                    ) : (
-                                        <span className="ai-model-status-not-ready" title={resolvedModel.status.message
-                                            || nls.localize('theia/ai/core/modelAliasesConfiguration/modelNotReadyTooltip', 'Not ready')}>✗</span>
-                                    )}
-                                </span>
-                            ) : (
-                                <span className="ai-configuration-value-row-value ai-alias-evaluates-to-unresolved">
-                                    {nls.localize('theia/ai/core/modelAliasesConfiguration/noResolvedModel', 'No model ready for this alias.')}
-                                    <span className="ai-model-status-not-ready"
-                                        title={nls.localize('theia/ai/core/modelAliasesConfiguration/noModelReadyTooltip', 'No model ready')}>✗</span>
-                                </span>
-                            )}
-                        </div>
-                    )}
-                </div>
-            );
+        {Object.values(lmRequirementMap).map(requirement => {
+            const isAlias = !!requirement.identifier && aliases.some(a => a.id === requirement.identifier);
+            const resolvedModel = isAlias && requirement.identifier ? resolvedAliasModels[requirement.identifier] : undefined;
+            const isOverridden = overriddenPurposes.has(requirement.purpose);
+            return <AiConfigurationSettingRow
+                key={requirement.purpose}
+                title={nls.localize('theia/ai/core/languageModelRenderer/purposeTitle', 'Purpose: {0}', requirement.purpose)}
+                modified={isOverridden}
+                below={<>
+                    <ModelSelect
+                        id={`model-select-${agent.id}-${requirement.purpose}`}
+                        purpose={requirement.purpose}
+                        value={requirement.identifier}
+                        options={modelSelectOptions}
+                        onSelect={onSelectedModelChange}
+                    />
+                    {isAlias && <div className='ai-lm-evaluates-to'>
+                        <span className='ai-lm-evaluates-to-label'>{nls.localize('theia/ai/core/modelAliasesConfiguration/evaluatesTo', 'Evaluates to')}:</span>
+                        {resolvedModel
+                            ? <span>{resolvedModel.name ?? resolvedModel.id} {resolvedModel.status.status === 'ready' ? '✓' : '✗'}</span>
+                            : <span className='ai-alias-evaluates-to-unresolved'>
+                                {nls.localize('theia/ai/core/modelAliasesConfiguration/noResolvedModel', 'No model ready for this alias.')}</span>}
+                    </div>}
+                </>}
+                onOpenMenu={gear => settingsRowService.openResetMenu(gear, () => onResetPurpose(requirement.purpose))}
+            />;
         })}
+        {reasoningModel?.reasoningSupport && <ReasoningRow
+            support={reasoningModel.reasoningSupport}
+            savedLevel={savedReasoningLevel}
+            inheritedLevel={inheritedReasoningLevel}
+            onSelect={onReasoningChange}
+            onReset={onResetReasoning}
+            settingsRowService={settingsRowService}
+        />}
     </div>;
 };

package/src/browser/app-tester-chat-agent.ts

@@ -20,8 +20,8 @@ import { AbstractStreamParsingChatAgent } from '@theia/ai-chat/lib/common/chat-a
 import { ErrorChatResponseContentImpl, MarkdownChatResponseContentImpl, MutableChatRequestModel, QuestionResponseContentImpl } from '@theia/ai-chat/lib/common/chat-model';
 import { LanguageModelRequirement } from '@theia/ai-core/lib/common';
 import { MCPFrontendService, MCPServerDescription } from '@theia/ai-mcp/lib/common/mcp-server-manager';
-import { nls } from '@theia/core';
-import { inject, injectable } from '@theia/core/shared/inversify';
+import { ILogger, nls } from '@theia/core';
+import { inject, injectable, named } from '@theia/core/shared/inversify';
 import { MCP_SERVERS_PREF } from '@theia/ai-mcp/lib/common/mcp-preferences';
 import { PreferenceScope, PreferenceService } from '@theia/core/lib/common';
 import { appTesterPlaywrightTemplate, appTesterDefaultTemplate, appTesterNextTemplate, REQUIRED_MCP_SERVERS, REQUIRED_MCP_SERVERS_NEXT } from './app-tester-prompt-template';
@@ -30,6 +30,9 @@ export const AppTesterChatAgentId = 'AppTester';
 @injectable()
 export class AppTesterChatAgent extends AbstractStreamParsingChatAgent {
 
+    @inject(ILogger) @named('ai-ide:AppTesterChatAgent')
+    protected override readonly logger: ILogger;
+
     @inject(MCPFrontendService)
     protected readonly mcpService: MCPFrontendService;
 

package/src/browser/architect-agent.ts

@@ -19,9 +19,9 @@ import {
 } from '@theia/ai-chat/lib/common';
 import { TaskContextStorageService } from '@theia/ai-chat/lib/browser/task-context-service';
 import { LanguageModelRequirement } from '@theia/ai-core';
-import { inject, injectable } from '@theia/core/shared/inversify';
+import { inject, injectable, named } from '@theia/core/shared/inversify';
 import { architectSystemVariants, ARCHITECT_PLANNING_PROMPT_ID, ARCHITECT_SIMPLE_PROMPT_ID, ARCHITECT_PLANNING_NEXT_PROMPT_ID } from './architect-prompt-template';
-import { nls } from '@theia/core';
+import { ILogger, nls } from '@theia/core';
 import { FrontendApplicationConfigProvider } from '@theia/core/lib/browser/frontend-application-config-provider';
 import { MarkdownStringImpl } from '@theia/core/lib/common/markdown-rendering';
 import { AI_EXECUTE_PLAN_WITH_CODER } from '../common/summarize-session-commands';
@@ -32,6 +32,9 @@ export { ArchitectAgentId };
 
 @injectable()
 export class ArchitectAgent extends AbstractModeAwareChatAgent {
+    @inject(ILogger) @named('ai-ide:ArchitectAgent')
+    protected override readonly logger: ILogger;
+
     @inject(ChatService) protected readonly chatService: ChatService;
     @inject(TaskContextStorageService) protected readonly taskContextStorageService: TaskContextStorageService;
 

package/src/browser/architect-prompt-template.ts

@@ -19,6 +19,7 @@ import {
   GET_WORKSPACE_FILE_LIST_FUNCTION_ID, FILE_CONTENT_FUNCTION_ID, SEARCH_IN_WORKSPACE_FUNCTION_ID, FIND_FILES_BY_PATTERN_FUNCTION_ID
 } from '../common/workspace-functions';
 import { CONTEXT_FILES_VARIABLE_ID, TASK_CONTEXT_SUMMARY_VARIABLE_ID } from '../common/context-variables';
+import { OPEN_EDITORS_HINT_FRAGMENT_ID } from '../common/open-editors-hint-fragment-id';
 import {
   CREATE_TASK_CONTEXT_FUNCTION_ID,
   GET_TASK_CONTEXT_FUNCTION_ID,
@@ -194,6 +195,8 @@ When a diagram clarifies an architectural concept or how something is implemente
 
 {{prompt:project-info}}
 
+{{prompt:${OPEN_EDITORS_HINT_FRAGMENT_ID}}}
+
 {{${TASK_CONTEXT_SUMMARY_VARIABLE_ID}}}
 `
   },
@@ -231,6 +234,8 @@ Always look at the relevant files to understand your task using the function ~{$
 {{${CONTEXT_FILES_VARIABLE_ID}}}
 
 {{prompt:project-info}}
+
+{{prompt:${OPEN_EDITORS_HINT_FRAGMENT_ID}}}
 `
     },
     {
@@ -464,6 +469,8 @@ When a diagram clarifies an architectural concept or how something is implemente
 
 {{prompt:project-info}}
 
+{{prompt:${OPEN_EDITORS_HINT_FRAGMENT_ID}}}
+
 {{${TASK_CONTEXT_SUMMARY_VARIABLE_ID}}}
 `
     }]

package/src/browser/chat-session-item.tsx

@@ -187,15 +187,13 @@ export function ChatSessionItem(props: ChatSessionItemComponentProps): React.Rea
 
     const handleMouseLeave = React.useCallback(() => {
         hoverActiveRef.current = false;
-        hoverService.cancelHover();
-    }, [hoverService]);
+    }, []);
 
     const handleMouseOver = React.useCallback((e: React.MouseEvent) => {
         if ((e.target as Element).closest('.theia-chat-session-item-action')) {
             hoverActiveRef.current = false;
-            hoverService.cancelHover();
         }
-    }, [hoverService]);
+    }, []);
 
     const handleKeyDown = React.useCallback((e: React.KeyboardEvent) => {
         if (isActivationKey(e)) {

package/src/browser/chat-session-list-service.ts

@@ -17,9 +17,9 @@
 import { ChatService, ChatSession, ChatSessionMetadata, ChatSessionStatus } from '@theia/ai-chat';
 import { PERSISTED_SESSION_LIMIT_PREF, SESSION_STORAGE_PREF } from '@theia/ai-chat/lib/common/ai-chat-preferences';
 import { ChatViewWidget } from '@theia/ai-chat-ui/lib/browser/chat-view-widget';
-import { DisposableCollection, Emitter, Event, PreferenceService } from '@theia/core';
+import { DisposableCollection, Emitter, Event, ILogger, PreferenceService } from '@theia/core';
 import { ApplicationShell } from '@theia/core/lib/browser';
-import { inject, injectable, postConstruct } from '@theia/core/shared/inversify';
+import { inject, injectable, named, postConstruct } from '@theia/core/shared/inversify';
 import { UnreadStateProvider } from './chat-session-item';
 import { SectionedSessions, SessionRow, parentIdOf } from './chat-session-list-components';
 
@@ -35,6 +35,9 @@ export class ChatSessionListService implements UnreadStateProvider {
     @inject(ApplicationShell)
     protected readonly shell: ApplicationShell;
 
+    @inject(ILogger) @named('ai-ide:ChatSessionListService')
+    protected readonly logger: ILogger;
+
     private readonly unreadSessions = new Map<string, {
         unread: boolean;
         requiresAction: boolean;
@@ -174,7 +177,7 @@ export class ChatSessionListService implements UnreadStateProvider {
             this._persistedSessions = Object.values(index)
                 .toSorted((a, b) => b.saveDate - a.saveDate);
         } catch (error) {
-            console.error('Failed to load persisted sessions:', error);
+            this.logger.error('Failed to load persisted sessions:', error);
             this._persistedSessions = [];
         } finally {
             this.onStateChangedEmitter.fire();

package/src/browser/code-reviewer-agent.ts

@@ -16,14 +16,17 @@
 
 import { AbstractStreamParsingChatAgent } from '@theia/ai-chat/lib/common/chat-agents';
 import { LanguageModelRequirement } from '@theia/ai-core/lib/common';
-import { nls } from '@theia/core';
-import { injectable } from '@theia/core/shared/inversify';
+import { ILogger, nls } from '@theia/core';
+import { inject, injectable, named } from '@theia/core/shared/inversify';
 import { codeReviewerSystemPrompt, CODE_REVIEWER_SYSTEM_PROMPT_ID } from './code-reviewer-prompt-template';
 
 export const CodeReviewerAgentId = 'code-reviewer';
 
 @injectable()
 export class CodeReviewerAgent extends AbstractStreamParsingChatAgent {
+    @inject(ILogger) @named('ai-ide:CodeReviewerAgent')
+    protected override readonly logger: ILogger;
+
     name = 'Code Reviewer';
     id = CodeReviewerAgentId;
     languageModelRequirements: LanguageModelRequirement[] = [{