@theia/ai-core 1.74.0-next.5 → 1.74.0-next.53

package/src/browser/ai-configuration-service-impl.spec.ts

@@ -0,0 +1,254 @@
+// *****************************************************************************
+// 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 { enableJSDOM } from '@theia/core/lib/browser/test/jsdom';
+const disableJSDOM = enableJSDOM();
+import { FrontendApplicationConfigProvider } from '@theia/core/lib/browser/frontend-application-config-provider';
+FrontendApplicationConfigProvider.set({});
+
+import { expect } from 'chai';
+import { Container } from '@theia/core/shared/inversify';
+import { Emitter, Event } from '@theia/core';
+import { Deferred } from '@theia/core/lib/common/promise-util';
+import { PreferenceChange, PreferenceInspection, PreferenceScope, PreferenceService } from '@theia/core/lib/common/preferences';
+import { WorkspaceTrustService } from '@theia/workspace/lib/browser/workspace-trust-service';
+import { TrustAwarePreferenceReader } from './trust-aware-preference-reader';
+import { AiConfigurationChange } from '../common/ai-configuration-service';
+import { AiConfigurationServiceImpl } from './ai-configuration-service-impl';
+
+disableJSDOM();
+
+const KEY = 'ai-features.someKey';
+
+/**
+ * Minimal in-memory `PreferenceService` stub that stores values per scope and derives the
+ * effective value with the same precedence as the real service.
+ */
+class StubPreferenceService {
+    readonly ready = Promise.resolve();
+    readonly isReady = true;
+
+    protected readonly values = new Map<string, Map<PreferenceScope, unknown>>();
+
+    protected readonly onPreferenceChangedEmitter = new Emitter<PreferenceChange>();
+    readonly onPreferenceChanged: Event<PreferenceChange> = this.onPreferenceChangedEmitter.event;
+
+    protected scopeMap(key: string): Map<PreferenceScope, unknown> {
+        let map = this.values.get(key);
+        if (!map) {
+            map = new Map();
+            this.values.set(key, map);
+        }
+        return map;
+    }
+
+    setScopeValue(key: string, scope: PreferenceScope, value: unknown): void {
+        this.scopeMap(key).set(scope, value);
+    }
+
+    get<T>(preferenceName: string, defaultValue?: T): T | undefined {
+        const inspection = this.inspect<T>(preferenceName);
+        return (inspection?.value as T | undefined) ?? defaultValue;
+    }
+
+    set(preferenceName: string, value: unknown, scope: PreferenceScope = PreferenceScope.User): Promise<void> {
+        this.scopeMap(preferenceName).set(scope, value);
+        this.fire(preferenceName, scope);
+        return Promise.resolve();
+    }
+
+    updateValue(preferenceName: string, value: unknown): Promise<void> {
+        return this.set(preferenceName, value, PreferenceScope.User);
+    }
+
+    inspect<T>(preferenceName: string): PreferenceInspection<T> | undefined {
+        const map = this.values.get(preferenceName);
+        const defaultValue = map?.get(PreferenceScope.Default) as T | undefined;
+        const globalValue = map?.get(PreferenceScope.User) as T | undefined;
+        const workspaceValue = map?.get(PreferenceScope.Workspace) as T | undefined;
+        const workspaceFolderValue = map?.get(PreferenceScope.Folder) as T | undefined;
+        const value = workspaceFolderValue ?? workspaceValue ?? globalValue ?? defaultValue;
+        return { preferenceName, defaultValue, globalValue, workspaceValue, workspaceFolderValue, value };
+    }
+
+    protected fire(preferenceName: string, scope: PreferenceScope): void {
+        this.onPreferenceChangedEmitter.fire({
+            preferenceName,
+            scope,
+            domain: undefined,
+            affects: () => true
+        } as unknown as PreferenceChange);
+    }
+}
+
+class StubWorkspaceTrustService {
+    readonly trustDeferred = new Deferred<boolean>();
+    protected readonly emitter = new Emitter<boolean>();
+    readonly onDidChangeWorkspaceTrust: Event<boolean> = this.emitter.event;
+
+    getWorkspaceTrust(): Promise<boolean> {
+        return this.trustDeferred.promise;
+    }
+
+    fireTrustChange(trusted: boolean): void {
+        this.emitter.fire(trusted);
+    }
+}
+
+describe('AiConfigurationServiceImpl', () => {
+    let preferences: StubPreferenceService;
+    let trust: StubWorkspaceTrustService;
+    let service: AiConfigurationServiceImpl;
+
+    const createService = async (trusted: boolean): Promise<void> => {
+        preferences = new StubPreferenceService();
+        trust = new StubWorkspaceTrustService();
+
+        const container = new Container();
+        container.bind(PreferenceService).toConstantValue(preferences as unknown as PreferenceService);
+        container.bind(WorkspaceTrustService).toConstantValue(trust as unknown as WorkspaceTrustService);
+        container.bind(TrustAwarePreferenceReader).toSelf().inSingletonScope();
+        container.bind(AiConfigurationServiceImpl).toSelf().inSingletonScope();
+
+        service = container.get(AiConfigurationServiceImpl);
+        trust.trustDeferred.resolve(trusted);
+        await service.ready;
+    };
+
+    describe('acceptance scenario', () => {
+        beforeEach(() => createService(true));
+
+        it('writes at User scope, reads back, reports User as source scope, and fires onDidChange', async () => {
+            const changes: AiConfigurationChange[] = [];
+            service.onDidChange(change => changes.push(change));
+
+            await service.set(KEY, true, PreferenceScope.User);
+
+            expect(service.get<boolean>(KEY)).to.equal(true);
+            expect(service.inspect(KEY)?.sourceScope).to.equal(PreferenceScope.User);
+            expect(changes.some(change => change.preferenceName === KEY)).to.equal(true);
+        });
+    });
+
+    describe('inspect source-scope derivation (trusted)', () => {
+        beforeEach(() => createService(true));
+
+        it('reports undefined source scope when only the default applies', () => {
+            preferences.setScopeValue(KEY, PreferenceScope.Default, 'default');
+            const inspection = service.inspect<string>(KEY);
+            expect(inspection?.sourceScope).to.equal(undefined);
+            expect(inspection?.value).to.equal('default');
+        });
+
+        it('reports User when a user value is set', () => {
+            preferences.setScopeValue(KEY, PreferenceScope.Default, 'default');
+            preferences.setScopeValue(KEY, PreferenceScope.User, 'user');
+            const inspection = service.inspect<string>(KEY);
+            expect(inspection?.sourceScope).to.equal(PreferenceScope.User);
+            expect(inspection?.value).to.equal('user');
+        });
+
+        it('reports Workspace when a workspace value wins', () => {
+            preferences.setScopeValue(KEY, PreferenceScope.User, 'user');
+            preferences.setScopeValue(KEY, PreferenceScope.Workspace, 'workspace');
+            const inspection = service.inspect<string>(KEY);
+            expect(inspection?.sourceScope).to.equal(PreferenceScope.Workspace);
+            expect(inspection?.value).to.equal('workspace');
+        });
+    });
+
+    describe('trust-aware reads', () => {
+        it('ignores the workspace value when untrusted', async () => {
+            await createService(false);
+            preferences.setScopeValue(KEY, PreferenceScope.Default, 'default');
+            preferences.setScopeValue(KEY, PreferenceScope.User, 'user');
+            preferences.setScopeValue(KEY, PreferenceScope.Workspace, 'workspace');
+
+            expect(service.get<string>(KEY)).to.equal('user');
+            const inspection = service.inspect<string>(KEY);
+            expect(inspection?.value).to.equal('user');
+            expect(inspection?.sourceScope).to.equal(PreferenceScope.User);
+            // The suppressed workspace/folder values are cleared, not just excluded from `value`.
+            expect(inspection?.workspaceValue).to.equal(undefined);
+            expect(inspection?.workspaceFolderValue).to.equal(undefined);
+        });
+
+        it('honors the workspace value when trusted', async () => {
+            await createService(true);
+            preferences.setScopeValue(KEY, PreferenceScope.User, 'user');
+            preferences.setScopeValue(KEY, PreferenceScope.Workspace, 'workspace');
+
+            expect(service.get<string>(KEY)).to.equal('workspace');
+            expect(service.inspect<string>(KEY)?.value).to.equal('workspace');
+        });
+
+        it('fires onDidChange (without a preference name) on a trust transition', async () => {
+            await createService(false);
+            const changes: AiConfigurationChange[] = [];
+            service.onDidChange(change => changes.push(change));
+
+            trust.fireTrustChange(true);
+
+            expect(changes).to.have.lengthOf(1);
+            expect(changes[0].preferenceName).to.equal(undefined);
+            expect(changes[0].affects()).to.equal(true);
+            // A trust transition affects every trust-gated (ai-features.*) key, but not unrelated ones.
+            expect(changes[0].affectsPreference(KEY)).to.equal(true);
+            expect(changes[0].affectsPreference('ai-features.anythingElse')).to.equal(true);
+            expect(changes[0].affectsPreference('editor.fontSize')).to.equal(false);
+        });
+    });
+
+    describe('set vs update', () => {
+        beforeEach(() => createService(true));
+
+        it('set writes the exact scope requested', async () => {
+            await service.set(KEY, 'workspace', PreferenceScope.Workspace);
+            expect(preferences.inspect<string>(KEY)?.workspaceValue).to.equal('workspace');
+            expect(preferences.inspect<string>(KEY)?.globalValue).to.equal(undefined);
+        });
+
+        it('update maps to updateValue (User scope)', async () => {
+            await service.update(KEY, 'user');
+            expect(preferences.inspect<string>(KEY)?.globalValue).to.equal('user');
+        });
+    });
+
+    describe('onDidChange filtering', () => {
+        beforeEach(() => createService(true));
+
+        it('only fires for ai-features.* keys', async () => {
+            const changes: AiConfigurationChange[] = [];
+            service.onDidChange(change => changes.push(change));
+
+            await service.set('editor.fontSize', 12, PreferenceScope.User);
+            await service.set(KEY, true, PreferenceScope.User);
+
+            expect(changes.map(change => change.preferenceName)).to.deep.equal([KEY]);
+        });
+
+        it('affectsPreference matches the changed key on a keyed change, not unrelated keys', async () => {
+            const changes: AiConfigurationChange[] = [];
+            service.onDidChange(change => changes.push(change));
+
+            await service.set(KEY, true, PreferenceScope.User);
+
+            expect(changes).to.have.lengthOf(1);
+            expect(changes[0].affectsPreference(KEY)).to.equal(true);
+            expect(changes[0].affectsPreference('ai-features.other')).to.equal(false);
+        });
+    });
+});

package/src/browser/ai-configuration-service-impl.ts

@@ -0,0 +1,120 @@
+// *****************************************************************************
+// 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 { DisposableCollection, Emitter, Event } from '@theia/core';
+import { inject, injectable, postConstruct } from '@theia/core/shared/inversify';
+import { JSONValue } from '@theia/core/shared/@lumino/coreutils';
+import { Deferred } from '@theia/core/lib/common/promise-util';
+import { PreferenceInspection, PreferenceScope, PreferenceService } from '@theia/core/lib/common/preferences';
+import { AiConfigurationChange, AiConfigurationInspection, AiConfigurationService } from '../common/ai-configuration-service';
+import { TrustAwarePreferenceReader } from './trust-aware-preference-reader';
+
+/**
+ * Prefix shared by all AI-related preference keys. Only changes to keys under this namespace are
+ * surfaced through {@link AiConfigurationService.onDidChange}.
+ */
+const AI_PREFERENCE_PREFIX = 'ai-features.';
+
+@injectable()
+export class AiConfigurationServiceImpl implements AiConfigurationService {
+
+    @inject(PreferenceService)
+    protected readonly preferenceService: PreferenceService;
+
+    @inject(TrustAwarePreferenceReader)
+    protected readonly trustAwareReader: TrustAwarePreferenceReader;
+
+    protected readonly toDispose = new DisposableCollection();
+
+    protected readonly onDidChangeEmitter = new Emitter<AiConfigurationChange>();
+    readonly onDidChange: Event<AiConfigurationChange> = this.onDidChangeEmitter.event;
+
+    protected readonly _ready = new Deferred<void>();
+    get ready(): Promise<void> {
+        return this._ready.promise;
+    }
+
+    @postConstruct()
+    protected init(): void {
+        this._ready.resolve(Promise.all([this.preferenceService.ready, this.trustAwareReader.ready]).then(() => undefined));
+        this.toDispose.push(this.onDidChangeEmitter);
+        this.toDispose.push(
+            this.preferenceService.onPreferenceChanged(change => {
+                if (change.preferenceName.startsWith(AI_PREFERENCE_PREFIX)) {
+                    this.onDidChangeEmitter.fire({
+                        preferenceName: change.preferenceName,
+                        affects: resourceUri => change.affects(resourceUri),
+                        affectsPreference: preferenceName => preferenceName === change.preferenceName
+                    });
+                }
+            })
+        );
+        this.toDispose.push(
+            // A trust transition can change the effective value of any trust-gated key. Emit a
+            // single change with no `preferenceName` and a sentinel `affects()` so listeners
+            // re-query, mirroring how trust-aware services already react to trust changes.
+            this.trustAwareReader.onDidChangeTrust(() => this.onDidChangeEmitter.fire({
+                preferenceName: undefined,
+                affects: () => true,
+                affectsPreference: preferenceName => preferenceName.startsWith(AI_PREFERENCE_PREFIX)
+            }))
+        );
+    }
+
+    get<T>(key: string, defaultValue?: T, resourceUri?: string): T | undefined {
+        return this.trustAwareReader.get<T>(key, defaultValue, resourceUri);
+    }
+
+    set(key: string, value: unknown, scope: PreferenceScope, resourceUri?: string): Promise<void> {
+        return this.preferenceService.set(key, value, scope, resourceUri);
+    }
+
+    update(key: string, value: unknown, resourceUri?: string): Promise<void> {
+        return this.preferenceService.updateValue(key, value, resourceUri);
+    }
+
+    inspect<T extends JSONValue>(key: string, resourceUri?: string): AiConfigurationInspection<T> | undefined {
+        const inspection = this.preferenceService.inspect<T>(key, resourceUri);
+        if (!inspection) {
+            return undefined;
+        }
+        return this.enrichInspection(inspection);
+    }
+
+    /**
+     * Derives the trust-aware {@link AiConfigurationInspection.sourceScope} and effective `value`
+     * from a raw {@link PreferenceInspection}. The workspace-trust rule is applied once, via
+     * {@link TrustAwarePreferenceReader.suppressUntrusted} (the single owner of that rule): when
+     * untrusted, folder and workspace scope values are cleared, so the scope walk below naturally
+     * resolves to the user/default scope and the whole inspection stays consistent with {@link get}.
+     *
+     * Note: `value` reflects the narrowest defined scope, matching `PreferenceService.inspect`. For
+     * object-valued preferences this can differ from {@link get}, which deep-merges across scopes.
+     */
+    protected enrichInspection<T extends JSONValue>(inspection: PreferenceInspection<T>): AiConfigurationInspection<T> {
+        const suppressed = this.trustAwareReader.suppressUntrusted(inspection);
+        if (suppressed.workspaceFolderValue !== undefined) {
+            return { ...suppressed, sourceScope: PreferenceScope.Folder, value: suppressed.workspaceFolderValue };
+        }
+        if (suppressed.workspaceValue !== undefined) {
+            return { ...suppressed, sourceScope: PreferenceScope.Workspace, value: suppressed.workspaceValue };
+        }
+        if (suppressed.globalValue !== undefined) {
+            return { ...suppressed, sourceScope: PreferenceScope.User, value: suppressed.globalValue };
+        }
+        return { ...suppressed, sourceScope: undefined, value: suppressed.defaultValue };
+    }
+}

package/src/browser/ai-core-frontend-module.ts

@@ -22,6 +22,7 @@ import {
 import { ContainerModule } from '@theia/core/shared/inversify';
 import { DefaultLanguageModelAliasRegistry } from './frontend-language-model-alias-registry';
 import { TrustAwarePreferenceReader } from './trust-aware-preference-reader';
+import { AiConfigurationServiceImpl } from './ai-configuration-service-impl';
 import { LanguageModelAliasRegistry } from '../common/language-model-alias';
 import {
     AIVariableContribution,
@@ -46,7 +47,8 @@ import {
     AIVariableResourceResolver,
     ConfigurableInMemoryResources,
     Agent,
-    FrontendLanguageModelRegistry
+    FrontendLanguageModelRegistry,
+    AiConfigurationService
 } from '../common';
 import {
     FrontendLanguageModelRegistryImpl,
@@ -196,8 +198,12 @@ export default new ContainerModule(bind => {
     bind(DefaultLanguageModelAliasRegistry).toSelf().inSingletonScope();
     bind(LanguageModelAliasRegistry).toService(DefaultLanguageModelAliasRegistry);
 
+    // Internal implementation detail of AiConfigurationService; consumers inject AiConfigurationService.
     bind(TrustAwarePreferenceReader).toSelf().inSingletonScope();
 
+    bind(AiConfigurationServiceImpl).toSelf().inSingletonScope();
+    bind(AiConfigurationService).toService(AiConfigurationServiceImpl);
+
     bind(TokenUsageService).toDynamicValue(ctx => {
         const connection = ctx.container.get<ServiceConnectionProvider>(RemoteConnectionProvider);
         const client = ctx.container.get<TokenUsageServiceClient>(TokenUsageServiceClient);

package/src/browser/ai-settings-service.ts

@@ -15,9 +15,7 @@
 // *****************************************************************************
 import { DisposableCollection, Emitter, Event, ILogger, RecursiveReadonly } from '@theia/core';
 import { inject, injectable, postConstruct } from '@theia/core/shared/inversify';
-import { PreferenceService } from '@theia/core/lib/common';
-import { AISettings, AISettingsService, AgentSettings } from '../common';
-import { TrustAwarePreferenceReader } from './trust-aware-preference-reader';
+import { AiConfigurationService, AISettings, AISettingsService, AgentSettings } from '../common';
 
 @injectable()
 export class AISettingsServiceImpl implements AISettingsService {
@@ -25,10 +23,8 @@ export class AISettingsServiceImpl implements AISettingsService {
     @inject(ILogger)
     protected readonly logger: ILogger;
 
-    @inject(PreferenceService) protected preferenceService: PreferenceService;
-
-    @inject(TrustAwarePreferenceReader)
-    protected readonly trustAwareReader: TrustAwarePreferenceReader;
+    @inject(AiConfigurationService)
+    protected readonly aiConfigurationService: AiConfigurationService;
 
     static readonly PREFERENCE_NAME = 'ai-features.agentSettings';
 
@@ -40,22 +36,19 @@ export class AISettingsServiceImpl implements AISettingsService {
     @postConstruct()
     protected init(): void {
         this.toDispose.push(
-            this.preferenceService.onPreferenceChanged(event => {
-                if (event.preferenceName === AISettingsServiceImpl.PREFERENCE_NAME) {
+            this.aiConfigurationService.onDidChange(change => {
+                if (change.affectsPreference(AISettingsServiceImpl.PREFERENCE_NAME)) {
                     this.onDidChangeEmitter.fire();
                 }
             })
         );
-        this.toDispose.push(
-            this.trustAwareReader.onDidChangeTrust(() => this.onDidChangeEmitter.fire())
-        );
     }
 
     async updateAgentSettings(agent: string, agentSettings: Partial<AgentSettings>): Promise<void> {
         const settings = await this.getSettings();
         const toSet = { ...settings, [agent]: { ...settings[agent], ...agentSettings } };
         try {
-            await this.preferenceService.updateValue(AISettingsServiceImpl.PREFERENCE_NAME, toSet);
+            await this.aiConfigurationService.update(AISettingsServiceImpl.PREFERENCE_NAME, toSet);
         } catch (e) {
             this.onDidChangeEmitter.fire();
             this.logger.warn('Updating the preferences was unsuccessful: ' + e);
@@ -68,8 +61,7 @@ export class AISettingsServiceImpl implements AISettingsService {
     }
 
     async getSettings(): Promise<RecursiveReadonly<AISettings>> {
-        await this.preferenceService.ready;
-        await this.trustAwareReader.ready;
-        return this.trustAwareReader.get<AISettings>(AISettingsServiceImpl.PREFERENCE_NAME, {}) ?? {};
+        await this.aiConfigurationService.ready;
+        return this.aiConfigurationService.get<AISettings>(AISettingsServiceImpl.PREFERENCE_NAME, {}) ?? {};
     }
 }

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

@@ -17,10 +17,10 @@
 import { injectable, inject, postConstruct } from '@theia/core/shared/inversify';
 import { Emitter, Event, nls } from '@theia/core';
 import { LanguageModelAlias, LanguageModelAliasRegistry } from '../common/language-model-alias';
-import { PreferenceScope, PreferenceService } from '@theia/core/lib/common';
+import { PreferenceScope } from '@theia/core/lib/common';
 import { LANGUAGE_MODEL_ALIASES_PREFERENCE } from '../common/ai-core-preferences';
 import { Deferred } from '@theia/core/lib/common/promise-util';
-import { TrustAwarePreferenceReader } from './trust-aware-preference-reader';
+import { AiConfigurationService } from '../common/ai-configuration-service';
 
 @injectable()
 export class DefaultLanguageModelAliasRegistry implements LanguageModelAliasRegistry {
@@ -76,11 +76,8 @@ export class DefaultLanguageModelAliasRegistry implements LanguageModelAliasRegi
     protected readonly onDidChangeEmitter = new Emitter<void>();
     readonly onDidChange: Event<void> = this.onDidChangeEmitter.event;
 
-    @inject(PreferenceService)
-    protected readonly preferenceService: PreferenceService;
-
-    @inject(TrustAwarePreferenceReader)
-    protected readonly trustAwareReader: TrustAwarePreferenceReader;
+    @inject(AiConfigurationService)
+    protected readonly aiConfigurationService: AiConfigurationService;
 
     protected readonly _ready = new Deferred<void>();
     get ready(): Promise<void> {
@@ -89,17 +86,16 @@ export class DefaultLanguageModelAliasRegistry implements LanguageModelAliasRegi
 
     @postConstruct()
     protected init(): void {
-        Promise.all([this.preferenceService.ready, this.trustAwareReader.ready]).then(() => {
+        this.aiConfigurationService.ready.then(() => {
             this.loadFromPreference();
-            this.preferenceService.onPreferenceChanged(ev => {
-                if (ev.preferenceName === LANGUAGE_MODEL_ALIASES_PREFERENCE) {
+            this.aiConfigurationService.onDidChange(change => {
+                if (change.affectsPreference(LANGUAGE_MODEL_ALIASES_PREFERENCE)) {
                     this.loadFromPreference();
+                    if (!change.preferenceName) {
+                        this.onDidChangeEmitter.fire();
+                    }
                 }
             });
-            this.trustAwareReader.onDidChangeTrust(() => {
-                this.loadFromPreference();
-                this.onDidChangeEmitter.fire();
-            });
             this._ready.resolve();
         }, err => {
             this._ready.reject(err);
@@ -158,7 +154,7 @@ export class DefaultLanguageModelAliasRegistry implements LanguageModelAliasRegi
      * Load aliases from the persisted setting
      */
     protected loadFromPreference(): void {
-        const stored = this.trustAwareReader.get<{ [name: string]: { selectedModel: string } }>(LANGUAGE_MODEL_ALIASES_PREFERENCE) || {};
+        const stored = this.aiConfigurationService.get<{ [name: string]: { selectedModel: string } }>(LANGUAGE_MODEL_ALIASES_PREFERENCE) || {};
         this.aliases.forEach(alias => {
             if (stored[alias.id] && stored[alias.id].selectedModel) {
                 alias.selectedModelId = stored[alias.id].selectedModel;
@@ -178,6 +174,6 @@ export class DefaultLanguageModelAliasRegistry implements LanguageModelAliasRegi
                 map[alias.id] = { selectedModel: alias.selectedModelId };
             }
         }
-        this.preferenceService.set(LANGUAGE_MODEL_ALIASES_PREFERENCE, map, PreferenceScope.User);
+        this.aiConfigurationService.set(LANGUAGE_MODEL_ALIASES_PREFERENCE, map, PreferenceScope.User);
     }
 }

package/src/browser/frontend-language-model-service.ts

@@ -18,7 +18,7 @@ import { nls } from '@theia/core/lib/common/nls';
 import { inject, injectable } from '@theia/core/shared/inversify';
 import { Prioritizeable } from '@theia/core/lib/common/prioritizeable';
 import { WorkspaceTrustService } from '@theia/workspace/lib/browser/workspace-trust-service';
-import { LanguageModel, LanguageModelResponse, ReasoningSettings, UserRequest } from '../common';
+import { AiConfigurationService, LanguageModel, LanguageModelResponse, ReasoningSettings, UserRequest } from '../common';
 import { LanguageModelServiceImpl } from '../common/language-model-service';
 import {
     PREFERENCE_NAME_REQUEST_SETTINGS,
@@ -27,7 +27,6 @@ import {
     ReasoningPreferenceEntry,
     getRequestSettingSpecificity
 } from '../common/ai-core-preferences';
-import { TrustAwarePreferenceReader } from './trust-aware-preference-reader';
 
 @injectable()
 export class FrontendLanguageModelServiceImpl extends LanguageModelServiceImpl {
@@ -35,15 +34,15 @@ export class FrontendLanguageModelServiceImpl extends LanguageModelServiceImpl {
     @inject(WorkspaceTrustService)
     protected readonly workspaceTrustService: WorkspaceTrustService;
 
-    @inject(TrustAwarePreferenceReader)
-    protected readonly trustAwareReader: TrustAwarePreferenceReader;
+    @inject(AiConfigurationService)
+    protected readonly aiConfiguration: AiConfigurationService;
 
     override async sendRequest(
         languageModel: LanguageModel,
         languageModelRequest: UserRequest
     ): Promise<LanguageModelResponse> {
-        const requestSettings = this.trustAwareReader.get<RequestSetting[]>(PREFERENCE_NAME_REQUEST_SETTINGS, []) ?? [];
-        const reasoningEntries = this.trustAwareReader.get<ReasoningPreferenceEntry[]>(PREFERENCE_NAME_REASONING, []) ?? [];
+        const requestSettings = this.aiConfiguration.get<RequestSetting[]>(PREFERENCE_NAME_REQUEST_SETTINGS, []) ?? [];
+        const reasoningEntries = this.aiConfiguration.get<ReasoningPreferenceEntry[]>(PREFERENCE_NAME_REASONING, []) ?? [];
         const trusted = await this.workspaceTrustService.getWorkspaceTrust();
         if (!trusted) {
             throw new Error(nls.localize('theia/ai-core/aiDisabledInRestrictedMode', 'AI features are not available in untrusted workspaces.'));