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

package/src/browser/style/index.css

@@ -1169,7 +1169,7 @@
   display: flex;
   align-items: center;
   gap: var(--theia-ui-padding);
-  padding: var(--theia-ui-padding) calc(var(--theia-ui-padding) * 2);
+  padding: var(--theia-ui-padding);
   border-radius: 3px;
   cursor: pointer;
   outline: none;
@@ -1187,13 +1187,20 @@
 }
 
 .theia-chat-session-item-icon-col {
-  position: relative;
   display: inline-flex;
   align-items: center;
   gap: calc(var(--theia-ui-padding) / 2);
   flex-shrink: 0;
 }
 
+/* Positioning context for the unread/attention badges so they anchor to the status icon itself
+   rather than to the whole column (which now also holds the expand toggle to the left). */
+.theia-chat-session-item-status-icon {
+  position: relative;
+  display: inline-flex;
+  align-items: center;
+}
+
 .theia-chat-session-item-unread-dot,
 .theia-chat-session-item-attention-dot {
   position: absolute;
@@ -1244,11 +1251,57 @@
    foreground so they stay readable on the highlighted background. */
 .theia-chat-session-item:focus .theia-chat-session-item-agent-icon,
 .theia-chat-session-item:focus .theia-chat-session-item-archive-icon,
+.theia-chat-session-item:focus .theia-chat-session-item-expand-icon,
 .theia-chat-session-item:focus-within .theia-chat-session-item-agent-icon,
-.theia-chat-session-item:focus-within .theia-chat-session-item-archive-icon {
+.theia-chat-session-item:focus-within .theia-chat-session-item-archive-icon,
+.theia-chat-session-item:focus-within .theia-chat-session-item-expand-icon {
   color: inherit;
 }
 
+/* Expand/collapse toggle shown next to the agent icon on parent sessions.
+   Non-parent rows render a same-sized placeholder so agent icons stay aligned. */
+.theia-chat-session-item-expand-icon {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  box-sizing: content-box;
+  width: var(--theia-ui-font-size0);
+  padding: calc(var(--theia-ui-padding) / 2);
+  border-radius: 3px;
+  color: var(--theia-descriptionForeground);
+  font-size: var(--theia-ui-font-size0);
+  outline: none;
+}
+
+.theia-chat-session-item-expand-icon:not(.theia-chat-session-item-expand-placeholder) {
+  cursor: pointer;
+}
+
+.theia-chat-session-item-expand-icon:not(.theia-chat-session-item-expand-placeholder):hover {
+  color: var(--theia-icon-foreground);
+  background-color: var(--theia-toolbar-hoverBackground, var(--theia-list-hoverBackground));
+}
+
+/* Only show a focus ring for keyboard focus, not on pointer clicks. */
+.theia-chat-session-item-expand-icon:focus-visible {
+  outline: 1px solid var(--theia-focusBorder);
+}
+
+/* The placeholder only reserves layout space and must not be interactive. */
+.theia-chat-session-item-expand-placeholder {
+  visibility: hidden;
+  pointer-events: none;
+}
+
+/* Child session indentation */
+.theia-chat-session-item-child {
+  padding-left: calc(var(--tree-indent, 0px) + var(--theia-ui-padding) * 3);
+}
+
+.theia-chat-session-item-child .theia-chat-session-item-content {
+  font-size: calc(var(--theia-ui-font-size1) * 0.95);
+}
+
 .theia-chat-session-item-content {
   flex: 1;
   min-width: 0;
@@ -2170,3 +2223,97 @@
   outline: 2px solid var(--theia-focusBorder);
   outline-offset: -2px;
 }
+
+/* AI Sessions View */
+.ai-sessions-view {
+  display: flex;
+  flex-direction: column;
+  height: 100%;
+}
+
+.ai-sessions-view-content {
+  flex: 1;
+  overflow-y: auto;
+  padding: var(--theia-ui-padding) 0;
+}
+
+.ai-sessions-view-empty {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  justify-content: center;
+  height: 100%;
+  color: var(--theia-descriptionForeground);
+  gap: var(--theia-ui-padding);
+}
+
+.ai-sessions-view-empty .codicon {
+  font-size: calc(var(--theia-ui-font-size1) * 2.5);
+  opacity: 0.5;
+}
+
+/* Persistent banner strip rendered above the AI chat content when an AI session
+ * override (e.g. --session-preference) is active. */
+.chat-banner-host {
+  flex: none;
+  width: 100%;
+}
+
+.chat-banner-host:empty {
+  display: none;
+}
+
+.theia-ai-allow-all-mode-strip {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  gap: calc(var(--theia-ui-padding) * 0.75);
+  padding: calc(var(--theia-ui-padding) * 0.6) calc(var(--theia-ui-padding) * 1.5);
+  background-color: var(--theia-inputValidation-warningBackground);
+  font-size: var(--theia-ui-font-size1);
+  line-height: 1.4;
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  cursor: default;
+}
+
+.theia-ai-allow-all-mode-strip.is-allow-all {
+  background-color: var(--theia-inputValidation-errorBackground);
+}
+
+.theia-ai-allow-all-mode-strip-icon {
+  flex: none;
+}
+
+.theia-ai-allow-all-mode-strip.is-allow-all .theia-ai-allow-all-mode-strip-icon {
+  color: var(--theia-errorForeground);
+}
+
+.theia-ai-allow-all-mode-strip-title {
+  font-weight: 600;
+}
+
+.theia-ai-allow-all-mode-strip-dismiss {
+  flex: none;
+  margin-left: calc(var(--theia-ui-padding) * 0.5);
+  padding: 2px;
+  background: transparent;
+  border: none;
+  border-radius: 3px;
+  color: inherit;
+  opacity: 0.7;
+  font: inherit;
+  line-height: 1;
+  cursor: pointer;
+}
+
+.theia-ai-allow-all-mode-strip-dismiss:hover {
+  opacity: 1;
+  background-color: var(--theia-toolbar-hoverBackground);
+}
+
+.theia-ai-allow-all-mode-strip-dismiss:focus {
+  outline: 1px solid var(--theia-focusBorder);
+  outline-offset: -1px;
+}

package/src/browser/workspace-functions.spec.ts

@@ -29,8 +29,7 @@ import {
     WorkspaceFunctionScope,
     FindFilesByPattern
 } from './workspace-functions';
-import { ToolInvocationContext } from '@theia/ai-core';
-import { TrustAwarePreferenceReader } from '@theia/ai-core/lib/browser/trust-aware-preference-reader';
+import { AiConfigurationService, ToolInvocationContext } from '@theia/ai-core';
 import { Container } from '@theia/core/shared/inversify';
 import { EnvVariablesServer } from '@theia/core/lib/common/env-variables';
 import { FileService } from '@theia/filesystem/lib/browser/file-service';
@@ -78,11 +77,11 @@ const makeRipgrepLikeSearchService = (filesByRoot: Record<string, string[]>) =>
         });
     });
 
-const makeTrustAwareReader = (overrides: { [pref: string]: unknown } = {}): TrustAwarePreferenceReader => ({
+const makeTrustAwareReader = (overrides: { [pref: string]: unknown } = {}): AiConfigurationService => ({
     get: <T>(name: string, fallback?: T) => (name in overrides ? overrides[name] as T : fallback),
     ready: Promise.resolve(),
     onDidChangeTrust: () => ({ dispose: () => { /* noop */ } })
-} as unknown as TrustAwarePreferenceReader);
+} as unknown as AiConfigurationService);
 
 const makeEnvVariablesServer = (homeDirUri: string = 'file:///home/test'): EnvVariablesServer => ({
     getHomeDirUri: async () => homeDirUri,
@@ -171,7 +170,7 @@ describe('Workspace Functions Cancellation Tests', () => {
         container.bind(MonacoWorkspace).toConstantValue(mockMonacoWorkspace);
         container.bind(ProblemManager).toConstantValue(mockProblemManager);
         container.bind(MonacoTextModelService).toConstantValue(mockMonacoTextModelService);
-        container.bind(TrustAwarePreferenceReader).toConstantValue(makeTrustAwareReader());
+        container.bind(AiConfigurationService).toConstantValue(makeTrustAwareReader());
         container.bind(EnvVariablesServer).toConstantValue(makeEnvVariablesServer());
         container.bind(FileSearchService).toConstantValue(makeFileSearchService());
         container.bind(WorkspaceFunctionScope).toSelf();
@@ -294,7 +293,7 @@ describe('FileContentFunction.getArgumentsShortLabel', () => {
         container.bind(FileService).toConstantValue(mockFileService);
         container.bind(PreferenceService).toConstantValue(mockPreferenceService);
         container.bind(MonacoWorkspace).toConstantValue(mockMonacoWorkspace);
-        container.bind(TrustAwarePreferenceReader).toConstantValue(makeTrustAwareReader());
+        container.bind(AiConfigurationService).toConstantValue(makeTrustAwareReader());
         container.bind(EnvVariablesServer).toConstantValue(makeEnvVariablesServer());
         container.bind(WorkspaceFunctionScope).toSelf();
         container.bind(FileContentFunction).toSelf();
@@ -412,7 +411,7 @@ describe('FileContentFunction handler', () => {
         container.bind(FileService).toConstantValue(mockFileService);
         container.bind(PreferenceService).toConstantValue(mockPreferenceService);
         container.bind(MonacoWorkspace).toConstantValue(mockMonacoWorkspace);
-        container.bind(TrustAwarePreferenceReader).toConstantValue(makeTrustAwareReader());
+        container.bind(AiConfigurationService).toConstantValue(makeTrustAwareReader());
         container.bind(EnvVariablesServer).toConstantValue(makeEnvVariablesServer());
         container.bind(WorkspaceFunctionScope).toSelf();
         container.bind(FileContentFunction).toSelf();
@@ -776,7 +775,7 @@ describe('FindFilesByPattern.getArgumentsShortLabel', () => {
         container.bind(WorkspaceService).toConstantValue(mockWorkspaceService);
         container.bind(FileService).toConstantValue(mockFileService);
         container.bind(PreferenceService).toConstantValue(mockPreferenceService);
-        container.bind(TrustAwarePreferenceReader).toConstantValue(makeTrustAwareReader());
+        container.bind(AiConfigurationService).toConstantValue(makeTrustAwareReader());
         container.bind(EnvVariablesServer).toConstantValue(makeEnvVariablesServer());
         container.bind(FileSearchService).toConstantValue(makeFileSearchService());
         container.bind(WorkspaceFunctionScope).toSelf();
@@ -852,14 +851,14 @@ describe('FindFilesByPattern.findFiles', () => {
                 (name === 'ai-features.workspaceFunctions.allowedExternalPaths' ? (allowedExternal as unknown as T) : fallback),
             ready: Promise.resolve(),
             onDidChangeTrust: () => ({ dispose: () => { /* noop */ } })
-        } as unknown as TrustAwarePreferenceReader;
+        } as unknown as AiConfigurationService;
 
         fileSearchService = makeFileSearchService(async () => searchResults);
 
         container.bind(WorkspaceService).toConstantValue(mockWorkspaceService);
         container.bind(FileService).toConstantValue(mockFileService);
         container.bind(PreferenceService).toConstantValue(mockPreferenceService);
-        container.bind(TrustAwarePreferenceReader).toConstantValue(trustAwareReader);
+        container.bind(AiConfigurationService).toConstantValue(trustAwareReader);
         container.bind(EnvVariablesServer).toConstantValue(makeEnvVariablesServer());
         container.bind(FileSearchService).toConstantValue(fileSearchService);
         container.bind(WorkspaceFunctionScope).toSelf();
@@ -996,7 +995,7 @@ describe('WorkspaceFunctionScope gitignore caching', () => {
         container.bind(WorkspaceService).toConstantValue(mockWorkspaceService);
         container.bind(FileService).toConstantValue(mockFileService);
         container.bind(PreferenceService).toConstantValue(mockPreferenceService);
-        container.bind(TrustAwarePreferenceReader).toConstantValue(makeTrustAwareReader());
+        container.bind(AiConfigurationService).toConstantValue(makeTrustAwareReader());
         container.bind(EnvVariablesServer).toConstantValue(makeEnvVariablesServer());
         container.bind(WorkspaceFunctionScope).toSelf();
 
@@ -1065,7 +1064,7 @@ describe('GetWorkspaceFileList resolves the target directory once', () => {
         container.bind(WorkspaceService).toConstantValue(mockWorkspaceService);
         container.bind(FileService).toConstantValue(mockFileService);
         container.bind(PreferenceService).toConstantValue(mockPreferenceService);
-        container.bind(TrustAwarePreferenceReader).toConstantValue(makeTrustAwareReader());
+        container.bind(AiConfigurationService).toConstantValue(makeTrustAwareReader());
         container.bind(EnvVariablesServer).toConstantValue(makeEnvVariablesServer());
         container.bind(WorkspaceFunctionScope).toSelf();
         container.bind(GetWorkspaceFileList).toSelf();
@@ -1128,7 +1127,7 @@ describe('GetWorkspaceDirectoryStructure preserves empty folders', () => {
         container.bind(WorkspaceService).toConstantValue(mockWorkspaceService);
         container.bind(FileService).toConstantValue(mockFileService);
         container.bind(PreferenceService).toConstantValue(mockPreferenceService);
-        container.bind(TrustAwarePreferenceReader).toConstantValue(makeTrustAwareReader());
+        container.bind(AiConfigurationService).toConstantValue(makeTrustAwareReader());
         container.bind(EnvVariablesServer).toConstantValue(makeEnvVariablesServer());
         container.bind(WorkspaceFunctionScope).toSelf();
         container.bind(GetWorkspaceDirectoryStructure).toSelf();
@@ -1194,13 +1193,13 @@ describe('FileContentFunction external paths', () => {
             get: <T>(_name: string, fallback?: T) => (trustedScopeOnly ? fallback : (allowedPaths as unknown as T)),
             ready: Promise.resolve(),
             onDidChangeTrust: () => ({ dispose: () => { /* noop */ } })
-        } as unknown as TrustAwarePreferenceReader;
+        } as unknown as AiConfigurationService;
 
         container.bind(WorkspaceService).toConstantValue(mockWorkspaceService);
         container.bind(FileService).toConstantValue(mockFileService);
         container.bind(PreferenceService).toConstantValue(mockPreferenceService);
         container.bind(MonacoWorkspace).toConstantValue(mockMonacoWorkspace);
-        container.bind(TrustAwarePreferenceReader).toConstantValue(trustAwareReader);
+        container.bind(AiConfigurationService).toConstantValue(trustAwareReader);
         container.bind(EnvVariablesServer).toConstantValue(makeEnvVariablesServer('file:///home/test'));
         container.bind(WorkspaceFunctionScope).toSelf();
         container.bind(FileContentFunction).toSelf();
@@ -1362,12 +1361,12 @@ describe('GetWorkspaceFileList / GetWorkspaceDirectoryStructure with external pa
             get: <T>(_name: string, _fallback?: T) => allowedPaths as unknown as T,
             ready: Promise.resolve(),
             onDidChangeTrust: () => ({ dispose: () => { /* noop */ } })
-        } as unknown as TrustAwarePreferenceReader;
+        } as unknown as AiConfigurationService;
 
         container.bind(WorkspaceService).toConstantValue(mockWorkspaceService);
         container.bind(FileService).toConstantValue(mockFileService);
         container.bind(PreferenceService).toConstantValue(mockPreferenceService);
-        container.bind(TrustAwarePreferenceReader).toConstantValue(trustAwareReader);
+        container.bind(AiConfigurationService).toConstantValue(trustAwareReader);
         container.bind(EnvVariablesServer).toConstantValue(makeEnvVariablesServer());
         container.bind(WorkspaceFunctionScope).toSelf();
         container.bind(GetWorkspaceFileList).toSelf();
@@ -1452,12 +1451,12 @@ describe('FindFilesByPattern with searchRoot', () => {
             get: <T>(_name: string, _fallback?: T) => allowedPaths as unknown as T,
             ready: Promise.resolve(),
             onDidChangeTrust: () => ({ dispose: () => { /* noop */ } })
-        } as unknown as TrustAwarePreferenceReader;
+        } as unknown as AiConfigurationService;
 
         container.bind(WorkspaceService).toConstantValue(mockWorkspaceService);
         container.bind(FileService).toConstantValue(mockFileService);
         container.bind(PreferenceService).toConstantValue(mockPreferenceService);
-        container.bind(TrustAwarePreferenceReader).toConstantValue(trustAwareReader);
+        container.bind(AiConfigurationService).toConstantValue(trustAwareReader);
         container.bind(EnvVariablesServer).toConstantValue(makeEnvVariablesServer());
         container.bind(FileSearchService).toConstantValue(makeRipgrepLikeSearchService(FILES_BY_ROOT));
         container.bind(WorkspaceFunctionScope).toSelf();
@@ -1547,13 +1546,13 @@ describe('WorkspaceFunctionScope path-traversal hardening', () => {
             get: <T>(name: string, fallback?: T) => trustAwareGet<T>(name, fallback),
             get ready(): Promise<void> { return trustReady; },
             onDidChangeTrust: () => ({ dispose: () => { /* noop */ } })
-        } as unknown as TrustAwarePreferenceReader;
+        } as unknown as AiConfigurationService;
 
         container.bind(WorkspaceService).toConstantValue(mockWorkspaceService);
         container.bind(FileService).toConstantValue(mockFileService);
         container.bind(PreferenceService).toConstantValue(mockPreferenceService);
         container.bind(MonacoWorkspace).toConstantValue(mockMonacoWorkspace);
-        container.bind(TrustAwarePreferenceReader).toConstantValue(trustAwareReader);
+        container.bind(AiConfigurationService).toConstantValue(trustAwareReader);
         container.bind(EnvVariablesServer).toConstantValue(makeEnvVariablesServer('file:///home/test'));
         container.bind(WorkspaceFunctionScope).toSelf();
         container.bind(FileContentFunction).toSelf();
@@ -1617,9 +1616,9 @@ describe('WorkspaceFunctionScope path-traversal hardening', () => {
         expect(parsed.error).to.include('not allowed');
     });
 
-    // Item 7 — getAllowedExternalUris must await TrustAwarePreferenceReader.ready
+    // Item 7 — getAllowedExternalUris must await AiConfigurationService.ready
     // so that preference reads see the resolved trust state.
-    it('awaits TrustAwarePreferenceReader.ready before reading the allow-list', async () => {
+    it('awaits AiConfigurationService.ready before reading the allow-list', async () => {
         let preferenceVisible = false;
         let resolveReady: () => void = () => { /* noop */ };
         trustReady = new Promise<void>(r => { resolveReady = r; });
@@ -1727,7 +1726,7 @@ describe('WorkspaceFunctionScope Multi-Root Tests', () => {
             container.bind(WorkspaceService).toConstantValue(mockWorkspaceService);
             container.bind(FileService).toConstantValue({} as FileService);
             container.bind(PreferenceService).toConstantValue({ get: () => false });
-            container.bind(TrustAwarePreferenceReader).toConstantValue(makeTrustAwareReader());
+            container.bind(AiConfigurationService).toConstantValue(makeTrustAwareReader());
             container.bind(EnvVariablesServer).toConstantValue(makeEnvVariablesServer());
             container.bind(WorkspaceFunctionScope).toSelf();
             workspaceScope = container.get(WorkspaceFunctionScope);
@@ -1750,7 +1749,7 @@ describe('WorkspaceFunctionScope Multi-Root Tests', () => {
             container.bind(WorkspaceService).toConstantValue(mockWorkspaceService);
             container.bind(FileService).toConstantValue({} as FileService);
             container.bind(PreferenceService).toConstantValue({ get: () => false });
-            container.bind(TrustAwarePreferenceReader).toConstantValue(makeTrustAwareReader());
+            container.bind(AiConfigurationService).toConstantValue(makeTrustAwareReader());
             container.bind(EnvVariablesServer).toConstantValue(makeEnvVariablesServer());
             container.bind(WorkspaceFunctionScope).toSelf();
             workspaceScope = container.get(WorkspaceFunctionScope);
@@ -1774,7 +1773,7 @@ describe('WorkspaceFunctionScope Multi-Root Tests', () => {
             container.bind(WorkspaceService).toConstantValue(mockWorkspaceService);
             container.bind(FileService).toConstantValue({} as FileService);
             container.bind(PreferenceService).toConstantValue({ get: () => false });
-            container.bind(TrustAwarePreferenceReader).toConstantValue(makeTrustAwareReader());
+            container.bind(AiConfigurationService).toConstantValue(makeTrustAwareReader());
             container.bind(EnvVariablesServer).toConstantValue(makeEnvVariablesServer());
             container.bind(WorkspaceFunctionScope).toSelf();
             workspaceScope = container.get(WorkspaceFunctionScope);
@@ -1797,7 +1796,7 @@ describe('WorkspaceFunctionScope Multi-Root Tests', () => {
             container.bind(WorkspaceService).toConstantValue(mockWorkspaceService);
             container.bind(FileService).toConstantValue({} as FileService);
             container.bind(PreferenceService).toConstantValue({ get: () => false });
-            container.bind(TrustAwarePreferenceReader).toConstantValue(makeTrustAwareReader());
+            container.bind(AiConfigurationService).toConstantValue(makeTrustAwareReader());
             container.bind(EnvVariablesServer).toConstantValue(makeEnvVariablesServer());
             container.bind(WorkspaceFunctionScope).toSelf();
             workspaceScope = container.get(WorkspaceFunctionScope);
@@ -1819,7 +1818,7 @@ describe('WorkspaceFunctionScope Multi-Root Tests', () => {
             container.bind(WorkspaceService).toConstantValue(mockWorkspaceService);
             container.bind(FileService).toConstantValue({} as FileService);
             container.bind(PreferenceService).toConstantValue({ get: () => false });
-            container.bind(TrustAwarePreferenceReader).toConstantValue(makeTrustAwareReader());
+            container.bind(AiConfigurationService).toConstantValue(makeTrustAwareReader());
             container.bind(EnvVariablesServer).toConstantValue(makeEnvVariablesServer());
             container.bind(WorkspaceFunctionScope).toSelf();
             workspaceScope = container.get(WorkspaceFunctionScope);
@@ -1840,7 +1839,7 @@ describe('WorkspaceFunctionScope Multi-Root Tests', () => {
             container.bind(WorkspaceService).toConstantValue(mockWorkspaceService);
             container.bind(FileService).toConstantValue({} as FileService);
             container.bind(PreferenceService).toConstantValue({ get: () => false });
-            container.bind(TrustAwarePreferenceReader).toConstantValue(makeTrustAwareReader());
+            container.bind(AiConfigurationService).toConstantValue(makeTrustAwareReader());
             container.bind(EnvVariablesServer).toConstantValue(makeEnvVariablesServer());
             container.bind(WorkspaceFunctionScope).toSelf();
             workspaceScope = container.get(WorkspaceFunctionScope);
@@ -1859,7 +1858,7 @@ describe('WorkspaceFunctionScope Multi-Root Tests', () => {
             container.bind(WorkspaceService).toConstantValue(mockWorkspaceService);
             container.bind(FileService).toConstantValue({} as FileService);
             container.bind(PreferenceService).toConstantValue({ get: () => false });
-            container.bind(TrustAwarePreferenceReader).toConstantValue(makeTrustAwareReader());
+            container.bind(AiConfigurationService).toConstantValue(makeTrustAwareReader());
             container.bind(EnvVariablesServer).toConstantValue(makeEnvVariablesServer());
             container.bind(WorkspaceFunctionScope).toSelf();
             workspaceScope = container.get(WorkspaceFunctionScope);
@@ -1881,7 +1880,7 @@ describe('WorkspaceFunctionScope Multi-Root Tests', () => {
             container.bind(WorkspaceService).toConstantValue(mockWorkspaceService);
             container.bind(FileService).toConstantValue({} as FileService);
             container.bind(PreferenceService).toConstantValue({ get: () => false });
-            container.bind(TrustAwarePreferenceReader).toConstantValue(makeTrustAwareReader());
+            container.bind(AiConfigurationService).toConstantValue(makeTrustAwareReader());
             container.bind(EnvVariablesServer).toConstantValue(makeEnvVariablesServer());
             container.bind(WorkspaceFunctionScope).toSelf();
             return container.get(WorkspaceFunctionScope);
@@ -2053,7 +2052,7 @@ describe('WorkspaceFunctionScope Multi-Root Tests', () => {
             container.bind(WorkspaceService).toConstantValue(mockWorkspaceServiceA);
             container.bind(FileService).toConstantValue({} as FileService);
             container.bind(PreferenceService).toConstantValue({ get: () => false });
-            container.bind(TrustAwarePreferenceReader).toConstantValue(makeTrustAwareReader());
+            container.bind(AiConfigurationService).toConstantValue(makeTrustAwareReader());
             container.bind(EnvVariablesServer).toConstantValue(makeEnvVariablesServer());
             container.bind(WorkspaceFunctionScope).toSelf();
             const scopeA = container.get(WorkspaceFunctionScope);
@@ -2072,7 +2071,7 @@ describe('WorkspaceFunctionScope Multi-Root Tests', () => {
             container2.bind(WorkspaceService).toConstantValue(mockWorkspaceServiceB);
             container2.bind(FileService).toConstantValue({} as FileService);
             container2.bind(PreferenceService).toConstantValue({ get: () => false });
-            container2.bind(TrustAwarePreferenceReader).toConstantValue(makeTrustAwareReader());
+            container2.bind(AiConfigurationService).toConstantValue(makeTrustAwareReader());
             container2.bind(EnvVariablesServer).toConstantValue(makeEnvVariablesServer());
             container2.bind(WorkspaceFunctionScope).toSelf();
             const scopeB = container2.get(WorkspaceFunctionScope);
@@ -2100,7 +2099,7 @@ describe('WorkspaceFunctionScope Multi-Root Tests', () => {
             container.bind(WorkspaceService).toConstantValue(mockWorkspaceService);
             container.bind(FileService).toConstantValue({} as FileService);
             container.bind(PreferenceService).toConstantValue({ get: () => false });
-            container.bind(TrustAwarePreferenceReader).toConstantValue(makeTrustAwareReader());
+            container.bind(AiConfigurationService).toConstantValue(makeTrustAwareReader());
             container.bind(EnvVariablesServer).toConstantValue(makeEnvVariablesServer());
             container.bind(WorkspaceFunctionScope).toSelf();
             workspaceScope = container.get(WorkspaceFunctionScope);
@@ -2127,7 +2126,7 @@ describe('WorkspaceFunctionScope Multi-Root Tests', () => {
             container.bind(WorkspaceService).toConstantValue(mockWorkspaceService);
             container.bind(FileService).toConstantValue({} as FileService);
             container.bind(PreferenceService).toConstantValue({ get: () => false });
-            container.bind(TrustAwarePreferenceReader).toConstantValue(makeTrustAwareReader());
+            container.bind(AiConfigurationService).toConstantValue(makeTrustAwareReader());
             container.bind(EnvVariablesServer).toConstantValue(makeEnvVariablesServer());
             container.bind(WorkspaceFunctionScope).toSelf();
             workspaceScope = container.get(WorkspaceFunctionScope);
@@ -2151,7 +2150,7 @@ describe('WorkspaceFunctionScope Multi-Root Tests', () => {
             container.bind(WorkspaceService).toConstantValue(mockWorkspaceService);
             container.bind(FileService).toConstantValue({} as FileService);
             container.bind(PreferenceService).toConstantValue({ get: () => false });
-            container.bind(TrustAwarePreferenceReader).toConstantValue(makeTrustAwareReader());
+            container.bind(AiConfigurationService).toConstantValue(makeTrustAwareReader());
             container.bind(EnvVariablesServer).toConstantValue(makeEnvVariablesServer());
             container.bind(WorkspaceFunctionScope).toSelf();
             workspaceScope = container.get(WorkspaceFunctionScope);
@@ -2175,7 +2174,7 @@ describe('WorkspaceFunctionScope Multi-Root Tests', () => {
             container.bind(WorkspaceService).toConstantValue(mockWorkspaceService);
             container.bind(FileService).toConstantValue({} as FileService);
             container.bind(PreferenceService).toConstantValue({ get: () => false });
-            container.bind(TrustAwarePreferenceReader).toConstantValue(makeTrustAwareReader());
+            container.bind(AiConfigurationService).toConstantValue(makeTrustAwareReader());
             container.bind(EnvVariablesServer).toConstantValue(makeEnvVariablesServer());
             container.bind(WorkspaceFunctionScope).toSelf();
             workspaceScope = container.get(WorkspaceFunctionScope);

package/src/browser/workspace-functions.ts

@@ -13,8 +13,7 @@
 //
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
-import { ToolInvocationContext, ToolProvider, ToolRequest } from '@theia/ai-core';
-import { TrustAwarePreferenceReader } from '@theia/ai-core/lib/browser/trust-aware-preference-reader';
+import { AiConfigurationService, ToolInvocationContext, ToolProvider, ToolRequest } from '@theia/ai-core';
 import { CancellationToken, Disposable, OS, PreferenceService, URI, Path } from '@theia/core';
 import { EnvVariablesServer } from '@theia/core/lib/common/env-variables';
 import { inject, injectable, postConstruct } from '@theia/core/shared/inversify';
@@ -54,8 +53,8 @@ export class WorkspaceFunctionScope {
     @inject(PreferenceService)
     protected readonly preferences: PreferenceService;
 
-    @inject(TrustAwarePreferenceReader)
-    protected readonly trustAwarePreferences: TrustAwarePreferenceReader;
+    @inject(AiConfigurationService)
+    protected readonly aiConfiguration: AiConfigurationService;
 
     @inject(EnvVariablesServer)
     protected readonly envVariablesServer: EnvVariablesServer;
@@ -379,15 +378,15 @@ export class WorkspaceFunctionScope {
 
     /**
      * Resolves the configured external allow-list to URIs. Reads via the
-     * trust-aware preference reader so workspace-scoped overrides are dropped
-     * when the workspace is untrusted. Awaits the reader's `ready` promise so
-     * that the trust state is resolved before the first preference read.
+     * trust-aware {@link AiConfigurationService} so workspace-scoped overrides are
+     * dropped when the workspace is untrusted. Awaits the service's `ready` promise
+     * so that the trust state is resolved before the first preference read.
      * Non-string entries, blanks, and entries that don't parse to a `file://`
      * URI are filtered out; URIs are returned in normalized form.
      */
     async getAllowedExternalUris(resourceUri?: string): Promise<URI[]> {
-        await this.trustAwarePreferences.ready;
-        const raw = this.trustAwarePreferences.get<string[]>(ALLOWED_EXTERNAL_PATHS_PREF, [], resourceUri) ?? [];
+        await this.aiConfiguration.ready;
+        const raw = this.aiConfiguration.get<string[]>(ALLOWED_EXTERNAL_PATHS_PREF, [], resourceUri) ?? [];
         const result: URI[] = [];
         for (const entry of raw) {
             if (typeof entry !== 'string') {

package/src/browser/workspace-launch-provider.spec.ts

@@ -35,16 +35,16 @@ import { DebugConfiguration } from '@theia/debug/lib/common/debug-common';
 import { DebugCompound } from '@theia/debug/lib/common/debug-compound';
 import { DebugSession } from '@theia/debug/lib/browser/debug-session';
 import { WorkspaceFunctionScope } from './workspace-functions';
-import { TrustAwarePreferenceReader } from '@theia/ai-core/lib/browser/trust-aware-preference-reader';
+import { AiConfigurationService } from '@theia/ai-core';
 import { EnvVariablesServer } from '@theia/core/lib/common/env-variables';
 import { WorkspaceService } from '@theia/workspace/lib/browser';
 import { FileService } from '@theia/filesystem/lib/browser/file-service';
 
-const makeTrustAwareReader = (): TrustAwarePreferenceReader => ({
+const makeTrustAwareReader = (): AiConfigurationService => ({
     get: <T>(_name: string, fallback?: T) => fallback,
     ready: Promise.resolve(),
     onDidChangeTrust: () => ({ dispose: () => { } })
-} as unknown as TrustAwarePreferenceReader);
+} as unknown as AiConfigurationService);
 
 const makeEnvVariablesServer = (): EnvVariablesServer => ({
     getHomeDirUri: async () => 'file:///home/test',
@@ -88,7 +88,7 @@ describe('Launch Management Tool Providers', () => {
         container.bind(WorkspaceService).toConstantValue(mockWorkspaceService);
         container.bind(FileService).toConstantValue({} as FileService);
         container.bind(PreferenceService).toConstantValue({ get: () => false } as unknown as PreferenceService);
-        container.bind(TrustAwarePreferenceReader).toConstantValue(makeTrustAwareReader());
+        container.bind(AiConfigurationService).toConstantValue(makeTrustAwareReader());
         container.bind(EnvVariablesServer).toConstantValue(makeEnvVariablesServer());
         container.bind(WorkspaceFunctionScope).toSelf();
 
@@ -396,7 +396,7 @@ describe('Launch Management Tool Providers', () => {
             multiRootContainer.bind(WorkspaceService).toConstantValue(multiRootWorkspaceService);
             multiRootContainer.bind(FileService).toConstantValue({} as FileService);
             multiRootContainer.bind(PreferenceService).toConstantValue({ get: () => false } as unknown as PreferenceService);
-            multiRootContainer.bind(TrustAwarePreferenceReader).toConstantValue(makeTrustAwareReader());
+            multiRootContainer.bind(AiConfigurationService).toConstantValue(makeTrustAwareReader());
             multiRootContainer.bind(EnvVariablesServer).toConstantValue(makeEnvVariablesServer());
             multiRootContainer.bind(WorkspaceFunctionScope).toSelf();