@theia/ai-chat 1.74.0-next.9 → 1.74.0

package/src/browser/chat-tool-preference-bindings.spec.ts

@@ -23,9 +23,7 @@ import {
     TOOL_CONFIRMATION_PREFERENCE,
     ToolConfirmationMode
 } from '../common/chat-tool-preferences';
-import { ToolRequest } from '@theia/ai-core';
-import { PreferenceService } from '@theia/core/lib/common/preferences';
-import { TrustAwarePreferenceReader } from '@theia/ai-core/lib/browser/trust-aware-preference-reader';
+import { AiConfigurationService, ToolRequest } from '@theia/ai-core';
 
 interface InspectResult<T> {
     defaultValue?: T;
@@ -35,8 +33,7 @@ interface InspectResult<T> {
 
 describe('ToolConfirmationManager', () => {
     let manager: ToolConfirmationManager;
-    let preferenceServiceMock: sinon.SinonStubbedInstance<PreferenceService>;
-    let trustAwareReaderMock: sinon.SinonStubbedInstance<TrustAwarePreferenceReader>;
+    let aiConfigurationServiceMock: sinon.SinonStubbedInstance<AiConfigurationService>;
     let storedPerToolPreferences: { [toolId: string]: ToolConfirmationMode };
     let storedDefaultMode: ToolConfirmationMode | undefined;
     let trusted: boolean;
@@ -58,27 +55,9 @@ describe('ToolConfirmationManager', () => {
         perToolInspectResult = undefined;
         defaultInspectResult = undefined;
 
-        preferenceServiceMock = {
-            updateValue: sinon.stub().callsFake((key: string, value: unknown) => {
-                if (key === TOOL_CONFIRMATION_PREFERENCE) {
-                    storedPerToolPreferences = value as { [toolId: string]: ToolConfirmationMode };
-                } else if (key === DEFAULT_TOOL_CONFIRMATION_PREFERENCE) {
-                    storedDefaultMode = value as ToolConfirmationMode;
-                }
-                return Promise.resolve();
-            }),
-            inspect: sinon.stub().callsFake((name: string) => {
-                if (name === TOOL_CONFIRMATION_PREFERENCE) {
-                    return perToolInspectResult;
-                }
-                if (name === DEFAULT_TOOL_CONFIRMATION_PREFERENCE) {
-                    return defaultInspectResult;
-                }
-                return undefined;
-            })
-        } as unknown as sinon.SinonStubbedInstance<PreferenceService>;
-
-        trustAwareReaderMock = {
+        // The manager talks only to AiConfigurationService. `get` mirrors the trust-aware read
+        // semantics, `update` the smart write, and `inspect` exposes schema defaults.
+        aiConfigurationServiceMock = {
             get: sinon.stub().callsFake(<T>(name: string, fallback?: T): T | undefined => {
                 if (name === TOOL_CONFIRMATION_PREFERENCE) {
                     if (trusted) {
@@ -95,13 +74,29 @@ describe('ToolConfirmationManager', () => {
                     return ((value as unknown as T) ?? fallback);
                 }
                 return fallback;
+            }),
+            update: sinon.stub().callsFake((key: string, value: unknown) => {
+                if (key === TOOL_CONFIRMATION_PREFERENCE) {
+                    storedPerToolPreferences = value as { [toolId: string]: ToolConfirmationMode };
+                } else if (key === DEFAULT_TOOL_CONFIRMATION_PREFERENCE) {
+                    storedDefaultMode = value as ToolConfirmationMode;
+                }
+                return Promise.resolve();
+            }),
+            inspect: sinon.stub().callsFake((name: string) => {
+                if (name === TOOL_CONFIRMATION_PREFERENCE) {
+                    return perToolInspectResult;
+                }
+                if (name === DEFAULT_TOOL_CONFIRMATION_PREFERENCE) {
+                    return defaultInspectResult;
+                }
+                return undefined;
             })
-        } as unknown as sinon.SinonStubbedInstance<TrustAwarePreferenceReader>;
+        } as unknown as sinon.SinonStubbedInstance<AiConfigurationService>;
 
         const container = new Container();
         container.bind(ToolConfirmationManager).toSelf().inSingletonScope();
-        container.bind(PreferenceService).toConstantValue(preferenceServiceMock as unknown as PreferenceService);
-        container.bind(TrustAwarePreferenceReader).toConstantValue(trustAwareReaderMock as unknown as TrustAwarePreferenceReader);
+        container.bind(AiConfigurationService).toConstantValue(aiConfigurationServiceMock as unknown as AiConfigurationService);
         manager = container.get(ToolConfirmationManager);
     });
 
@@ -124,9 +119,9 @@ describe('ToolConfirmationManager', () => {
     describe('setDefaultConfirmationMode', () => {
         it('persists the new default through the preference service', () => {
             manager.setDefaultConfirmationMode(ToolConfirmationMode.ALWAYS_ALLOW);
-            expect(preferenceServiceMock.updateValue.calledOnce).to.be.true;
-            expect(preferenceServiceMock.updateValue.firstCall.args[0]).to.equal(DEFAULT_TOOL_CONFIRMATION_PREFERENCE);
-            expect(preferenceServiceMock.updateValue.firstCall.args[1]).to.equal(ToolConfirmationMode.ALWAYS_ALLOW);
+            expect(aiConfigurationServiceMock.update.calledOnce).to.be.true;
+            expect(aiConfigurationServiceMock.update.firstCall.args[0]).to.equal(DEFAULT_TOOL_CONFIRMATION_PREFERENCE);
+            expect(aiConfigurationServiceMock.update.firstCall.args[1]).to.equal(ToolConfirmationMode.ALWAYS_ALLOW);
             expect(storedDefaultMode).to.equal(ToolConfirmationMode.ALWAYS_ALLOW);
         });
     });
@@ -223,31 +218,31 @@ describe('ToolConfirmationManager', () => {
     describe('setConfirmationMode', () => {
         it('persists ALWAYS_ALLOW for a regular tool when default is CONFIRM', () => {
             manager.setConfirmationMode('regularTool', ToolConfirmationMode.ALWAYS_ALLOW);
-            expect(preferenceServiceMock.updateValue.calledOnce).to.be.true;
+            expect(aiConfigurationServiceMock.update.calledOnce).to.be.true;
             expect(storedPerToolPreferences['regularTool']).to.equal(ToolConfirmationMode.ALWAYS_ALLOW);
         });
 
         it('persists ALWAYS_ALLOW for confirmAlwaysAllow tools', () => {
             const toolRequest = createToolRequest('dangerousTool', true);
             manager.setConfirmationMode('dangerousTool', ToolConfirmationMode.ALWAYS_ALLOW, toolRequest);
-            expect(preferenceServiceMock.updateValue.calledOnce).to.be.true;
+            expect(aiConfigurationServiceMock.update.calledOnce).to.be.true;
             expect(storedPerToolPreferences['dangerousTool']).to.equal(ToolConfirmationMode.ALWAYS_ALLOW);
         });
 
         it('does not persist when mode matches the global default', () => {
             storedDefaultMode = ToolConfirmationMode.ALWAYS_ALLOW;
             manager.setConfirmationMode('regularTool', ToolConfirmationMode.ALWAYS_ALLOW);
-            expect(preferenceServiceMock.updateValue.called).to.be.false;
+            expect(aiConfigurationServiceMock.update.called).to.be.false;
         });
 
         it('does not persist CONFIRM for a regular tool when default is CONFIRM', () => {
             manager.setConfirmationMode('regularTool', ToolConfirmationMode.CONFIRM);
-            expect(preferenceServiceMock.updateValue.called).to.be.false;
+            expect(aiConfigurationServiceMock.update.called).to.be.false;
         });
 
         it('persists DISABLED when default is CONFIRM', () => {
             manager.setConfirmationMode('regularTool', ToolConfirmationMode.DISABLED);
-            expect(preferenceServiceMock.updateValue.calledOnce).to.be.true;
+            expect(aiConfigurationServiceMock.update.calledOnce).to.be.true;
             expect(storedPerToolPreferences['regularTool']).to.equal(ToolConfirmationMode.DISABLED);
         });
 
@@ -256,7 +251,7 @@ describe('ToolConfirmationManager', () => {
                 defaultValue: { 'myTool': ToolConfirmationMode.DISABLED }
             };
             manager.setConfirmationMode('myTool', ToolConfirmationMode.DISABLED);
-            expect(preferenceServiceMock.updateValue.called).to.be.false;
+            expect(aiConfigurationServiceMock.update.called).to.be.false;
         });
 
         it('removes an existing entry when mode matches the tool-specific schema default', () => {
@@ -265,14 +260,14 @@ describe('ToolConfirmationManager', () => {
             };
             storedPerToolPreferences['myTool'] = ToolConfirmationMode.ALWAYS_ALLOW;
             manager.setConfirmationMode('myTool', ToolConfirmationMode.DISABLED);
-            expect(preferenceServiceMock.updateValue.calledOnce).to.be.true;
+            expect(aiConfigurationServiceMock.update.calledOnce).to.be.true;
             expect(storedPerToolPreferences['myTool']).to.be.undefined;
         });
 
         it('does not persist CONFIRM for confirmAlwaysAllow tools (matches effective default)', () => {
             const toolRequest = createToolRequest('dangerousTool', true);
             manager.setConfirmationMode('dangerousTool', ToolConfirmationMode.CONFIRM, toolRequest);
-            expect(preferenceServiceMock.updateValue.called).to.be.false;
+            expect(aiConfigurationServiceMock.update.called).to.be.false;
         });
 
         it('persists ALWAYS_ALLOW for a confirmAlwaysAllow tool when global default is ALWAYS_ALLOW', () => {
@@ -281,7 +276,7 @@ describe('ToolConfirmationManager', () => {
             storedDefaultMode = ToolConfirmationMode.ALWAYS_ALLOW;
             const toolRequest = createToolRequest('dangerousTool', true);
             manager.setConfirmationMode('dangerousTool', ToolConfirmationMode.ALWAYS_ALLOW, toolRequest);
-            expect(preferenceServiceMock.updateValue.calledOnce).to.be.true;
+            expect(aiConfigurationServiceMock.update.calledOnce).to.be.true;
             expect(storedPerToolPreferences['dangerousTool']).to.equal(ToolConfirmationMode.ALWAYS_ALLOW);
         });
 
@@ -289,13 +284,13 @@ describe('ToolConfirmationManager', () => {
             const toolRequest = createToolRequest('dangerousTool', true);
             storedPerToolPreferences['dangerousTool'] = ToolConfirmationMode.ALWAYS_ALLOW;
             manager.setConfirmationMode('dangerousTool', ToolConfirmationMode.CONFIRM, toolRequest);
-            expect(preferenceServiceMock.updateValue.calledOnce).to.be.true;
+            expect(aiConfigurationServiceMock.update.calledOnce).to.be.true;
             expect(storedPerToolPreferences['dangerousTool']).to.be.undefined;
         });
 
         it('persists DISABLED for any tool when default is CONFIRM', () => {
             manager.setConfirmationMode('anyTool', ToolConfirmationMode.DISABLED);
-            expect(preferenceServiceMock.updateValue.calledOnce).to.be.true;
+            expect(aiConfigurationServiceMock.update.calledOnce).to.be.true;
             expect(storedPerToolPreferences['anyTool']).to.equal(ToolConfirmationMode.DISABLED);
         });
     });
@@ -362,9 +357,9 @@ describe('ToolConfirmationManager', () => {
 
             manager.resetAllConfirmationModeSettings();
 
-            expect(preferenceServiceMock.updateValue.calledOnce).to.be.true;
-            expect(preferenceServiceMock.updateValue.firstCall.args[0]).to.equal(TOOL_CONFIRMATION_PREFERENCE);
-            expect(preferenceServiceMock.updateValue.firstCall.args[1]).to.deep.equal({});
+            expect(aiConfigurationServiceMock.update.calledOnce).to.be.true;
+            expect(aiConfigurationServiceMock.update.firstCall.args[0]).to.equal(TOOL_CONFIRMATION_PREFERENCE);
+            expect(aiConfigurationServiceMock.update.firstCall.args[1]).to.deep.equal({});
         });
 
         it('does not modify the default-confirmation preference', () => {
@@ -386,7 +381,7 @@ describe('ToolConfirmationManager', () => {
 
             manager.setConfirmationMode('shellExecute', ToolConfirmationMode.ALWAYS_ALLOW, toolRequest);
 
-            expect(preferenceServiceMock.updateValue.calledOnce).to.be.true;
+            expect(aiConfigurationServiceMock.update.calledOnce).to.be.true;
             expect(storedPerToolPreferences['shellExecute']).to.equal(ToolConfirmationMode.ALWAYS_ALLOW);
 
             mode = manager.getConfirmationMode('shellExecute', 'chat-1', toolRequest);
@@ -398,7 +393,7 @@ describe('ToolConfirmationManager', () => {
 
             manager.setConfirmationMode('shellExecute', ToolConfirmationMode.DISABLED, toolRequest);
 
-            expect(preferenceServiceMock.updateValue.calledOnce).to.be.true;
+            expect(aiConfigurationServiceMock.update.calledOnce).to.be.true;
             expect(storedPerToolPreferences['shellExecute']).to.equal(ToolConfirmationMode.DISABLED);
 
             const mode = manager.getConfirmationMode('shellExecute', 'chat-1', toolRequest);

package/src/browser/chat-tool-preference-bindings.ts

@@ -15,27 +15,30 @@
 // *****************************************************************************
 
 import { injectable, inject } from '@theia/core/shared/inversify';
-import {
-    PreferenceService,
-} from '@theia/core/lib/common/preferences';
 import {
     ToolConfirmationMode,
     TOOL_CONFIRMATION_PREFERENCE,
     DEFAULT_TOOL_CONFIRMATION_PREFERENCE
 } from '../common/chat-tool-preferences';
-import { ToolRequest } from '@theia/ai-core';
-import { TrustAwarePreferenceReader } from '@theia/ai-core/lib/browser/trust-aware-preference-reader';
+import { AiConfigurationService, ToolRequest } from '@theia/ai-core';
+
+/**
+ * The loop-invariant inputs to {@link ToolConfirmationManager.computeEffectiveDefaultForTool}:
+ * the product-shipped per-tool schema defaults and the effective global default. Reading these
+ * once lets bulk operations avoid re-inspecting the preference schema per tool.
+ */
+interface ToolConfirmationDefaults {
+    perToolDefaults?: { [toolId: string]: ToolConfirmationMode };
+    globalDefault: ToolConfirmationMode;
+}
 
 /**
  * Utility class to manage tool confirmation settings
  */
 @injectable()
 export class ToolConfirmationManager {
-    @inject(PreferenceService)
-    protected readonly preferenceService: PreferenceService;
-
-    @inject(TrustAwarePreferenceReader)
-    protected readonly trustAwareReader: TrustAwarePreferenceReader;
+    @inject(AiConfigurationService)
+    protected readonly aiConfigurationService: AiConfigurationService;
 
     // In-memory session overrides (not persisted), per chat
     protected sessionOverrides: Map<string, Map<string, ToolConfirmationMode>> = new Map();
@@ -47,7 +50,7 @@ export class ToolConfirmationManager {
      * the default to a more permissive value.
      */
     getDefaultConfirmationMode(): ToolConfirmationMode {
-        const value = this.trustAwareReader.get<ToolConfirmationMode>(DEFAULT_TOOL_CONFIRMATION_PREFERENCE);
+        const value = this.aiConfigurationService.get<ToolConfirmationMode>(DEFAULT_TOOL_CONFIRMATION_PREFERENCE);
         return value ?? this.getDefaultPreferenceSchemaDefault();
     }
 
@@ -58,7 +61,7 @@ export class ToolConfirmationManager {
      * `await` completion and react to errors (e.g. show a notification on failure).
      */
     setDefaultConfirmationMode(mode: ToolConfirmationMode): Promise<void> {
-        return this.preferenceService.updateValue(DEFAULT_TOOL_CONFIRMATION_PREFERENCE, mode);
+        return this.aiConfigurationService.update(DEFAULT_TOOL_CONFIRMATION_PREFERENCE, mode);
     }
 
     /**
@@ -77,7 +80,7 @@ export class ToolConfirmationManager {
         if (chatMap && chatMap.has(toolId)) {
             return chatMap.get(toolId)!;
         }
-        const toolConfirmation = this.trustAwareReader.get<Record<string, ToolConfirmationMode>>(
+        const toolConfirmation = this.aiConfigurationService.get<Record<string, ToolConfirmationMode>>(
             TOOL_CONFIRMATION_PREFERENCE, {}
         ) ?? {};
         if (toolId in toolConfirmation) {
@@ -99,19 +102,19 @@ export class ToolConfirmationManager {
      * @param toolRequest - Optional ToolRequest to check for confirmAlwaysAllow flag
      */
     setConfirmationMode(toolId: string, mode: ToolConfirmationMode, toolRequest?: ToolRequest): Promise<void> {
-        const current = this.trustAwareReader.get<Record<string, ToolConfirmationMode>>(
+        const current = this.aiConfigurationService.get<Record<string, ToolConfirmationMode>>(
             TOOL_CONFIRMATION_PREFERENCE, {}
         ) ?? {};
         const effectiveDefault = this.computeEffectiveDefaultForTool(toolId, toolRequest);
         if (mode === effectiveDefault) {
             if (toolId in current) {
                 const { [toolId]: _, ...rest } = current;
-                return this.preferenceService.updateValue(TOOL_CONFIRMATION_PREFERENCE, rest);
+                return this.aiConfigurationService.update(TOOL_CONFIRMATION_PREFERENCE, rest);
             }
             return Promise.resolve();
         }
         const updated = { ...current, [toolId]: mode };
-        return this.preferenceService.updateValue(TOOL_CONFIRMATION_PREFERENCE, updated);
+        return this.aiConfigurationService.update(TOOL_CONFIRMATION_PREFERENCE, updated);
     }
 
     /**
@@ -122,13 +125,15 @@ export class ToolConfirmationManager {
      * round-trip per tool.
      */
     setConfirmationModes(updates: Iterable<{ toolId: string; mode: ToolConfirmationMode; toolRequest?: ToolRequest }>): Promise<void> {
-        const current = this.trustAwareReader.get<Record<string, ToolConfirmationMode>>(
+        const current = this.aiConfigurationService.get<Record<string, ToolConfirmationMode>>(
             TOOL_CONFIRMATION_PREFERENCE, {}
         ) ?? {};
         const next: Record<string, ToolConfirmationMode> = { ...current };
+        // Read the loop-invariant schema/global defaults once, not once per tool.
+        const defaults = this.readConfirmationDefaults();
         let changed = false;
         for (const { toolId, mode, toolRequest } of updates) {
-            const effectiveDefault = this.computeEffectiveDefaultForTool(toolId, toolRequest);
+            const effectiveDefault = this.computeEffectiveDefaultForTool(toolId, toolRequest, defaults);
             if (mode === effectiveDefault) {
                 if (toolId in next) {
                     delete next[toolId];
@@ -143,7 +148,7 @@ export class ToolConfirmationManager {
         if (!changed) {
             return Promise.resolve();
         }
-        return this.preferenceService.updateValue(TOOL_CONFIRMATION_PREFERENCE, next);
+        return this.aiConfigurationService.update(TOOL_CONFIRMATION_PREFERENCE, next);
     }
 
     /**
@@ -173,32 +178,39 @@ export class ToolConfirmationManager {
      * Get all tool confirmation settings
      */
     getAllConfirmationSettings(): { [toolId: string]: ToolConfirmationMode } {
-        return this.trustAwareReader.get<Record<string, ToolConfirmationMode>>(
+        return this.aiConfigurationService.get<Record<string, ToolConfirmationMode>>(
             TOOL_CONFIRMATION_PREFERENCE, {}
         ) ?? {};
     }
 
     resetAllConfirmationModeSettings(): Promise<void> {
-        return this.preferenceService.updateValue(TOOL_CONFIRMATION_PREFERENCE, {});
+        return this.aiConfigurationService.update(TOOL_CONFIRMATION_PREFERENCE, {});
     }
 
     /**
-     * Compute the effective default for a given tool, taking the schema-level default,
-     * any product-shipped per-tool default, and the confirmAlwaysAllow flag into account.
+     * Read the loop-invariant inputs for {@link computeEffectiveDefaultForTool}: the product-shipped
+     * per-tool schema defaults and the effective global default.
      */
-    protected computeEffectiveDefaultForTool(toolId: string, toolRequest?: ToolRequest): ToolConfirmationMode {
-        const perToolDefaults = this.preferenceService.inspect(TOOL_CONFIRMATION_PREFERENCE)?.defaultValue as
+    protected readConfirmationDefaults(): ToolConfirmationDefaults {
+        const perToolDefaults = this.aiConfigurationService.inspect(TOOL_CONFIRMATION_PREFERENCE)?.defaultValue as
             | { [toolId: string]: ToolConfirmationMode }
             | undefined;
-        const perToolDefault = perToolDefaults?.[toolId];
+        return { perToolDefaults, globalDefault: this.getDefaultConfirmationMode() };
+    }
+
+    protected computeEffectiveDefaultForTool(
+        toolId: string,
+        toolRequest?: ToolRequest,
+        defaults: ToolConfirmationDefaults = this.readConfirmationDefaults()
+    ): ToolConfirmationMode {
+        const perToolDefault = defaults.perToolDefaults?.[toolId];
         if (perToolDefault) {
             return perToolDefault;
         }
-        const globalDefault = this.getDefaultConfirmationMode();
-        if (toolRequest?.confirmAlwaysAllow && globalDefault === ToolConfirmationMode.ALWAYS_ALLOW) {
+        if (toolRequest?.confirmAlwaysAllow && defaults.globalDefault === ToolConfirmationMode.ALWAYS_ALLOW) {
             return ToolConfirmationMode.CONFIRM;
         }
-        return globalDefault;
+        return defaults.globalDefault;
     }
 
     /**
@@ -206,7 +218,7 @@ export class ToolConfirmationManager {
      * Falls back to CONFIRM if the preference service has not registered the schema yet.
      */
     protected getDefaultPreferenceSchemaDefault(): ToolConfirmationMode {
-        const schemaDefault = this.preferenceService.inspect(DEFAULT_TOOL_CONFIRMATION_PREFERENCE)?.defaultValue as
+        const schemaDefault = this.aiConfigurationService.inspect(DEFAULT_TOOL_CONFIRMATION_PREFERENCE)?.defaultValue as
             | ToolConfirmationMode
             | undefined;
         return schemaDefault ?? ToolConfirmationMode.CONFIRM;

package/src/common/chat-agents.spec.ts

@@ -17,9 +17,14 @@
 import 'reflect-metadata';
 
 import { expect } from 'chai';
-import { LanguageModel, LanguageModelMessage, LanguageModelRequirement, LanguageModelResponse, LanguageModelService, ServerToolDescriptor, UserRequest } from '@theia/ai-core';
-import { AbstractChatAgent, ChatAgentLocation } from './chat-agents';
 import {
+    LanguageModel, LanguageModelMessage, LanguageModelRegistry, LanguageModelRequirement, LanguageModelResponse,
+    LanguageModelSelector, LanguageModelService, LanguageModelStreamResponsePart, ServerToolDescriptor, UserRequest
+} from '@theia/ai-core';
+import { AbstractChatAgent, AbstractStreamParsingChatAgent, ChatAgentLocation } from './chat-agents';
+import {
+    ChatResponseContent,
+    CompactionChatResponseContent,
     MutableChatModel,
     MutableChatRequestModel,
     ChatModel,
@@ -46,6 +51,14 @@ class TestChatAgent extends AbstractChatAgent {
     public exposeSendLlmRequest(request: MutableChatRequestModel, languageModel: LanguageModel): Promise<LanguageModelResponse> {
         return this.sendLlmRequest(request, [], [], undefined, languageModel);
     }
+
+    public exposeGetLanguageModelForRequest(request: MutableChatRequestModel, purpose = 'chat'): Promise<LanguageModel> {
+        return this.getLanguageModelForRequest(request, purpose);
+    }
+
+    public setLanguageModelRegistry(registry: LanguageModelRegistry): void {
+        this.languageModelRegistry = registry;
+    }
 }
 
 function createParsedRequest(text: string, request?: Partial<ChatRequest>): ParsedChatRequest {
@@ -182,3 +195,100 @@ describe('AbstractChatAgent.sendLlmRequest server tools', () => {
         expect(captured()!.serverTools).to.equal(undefined);
     });
 });
+
+class StreamParsingTestChatAgent extends AbstractStreamParsingChatAgent {
+    readonly id = 'stream-test-agent';
+    readonly name = 'Stream Test Agent';
+    readonly languageModelRequirements: LanguageModelRequirement[] = [];
+    protected readonly defaultLanguageModelPurpose = 'chat';
+
+    exposeParse(token: LanguageModelStreamResponsePart): ChatResponseContent | ChatResponseContent[] {
+        return this.parse(token, undefined as never);
+    }
+}
+
+describe('AbstractChatAgent.parse compaction', () => {
+    it('creates compaction content from a compaction response part', () => {
+        const agent = new StreamParsingTestChatAgent();
+        const content = agent.exposeParse({ compaction: { provider: 'anthropic', data: { b: 1 }, summary: 's' } });
+        expect(ChatResponseContent.is(content)).to.equal(true);
+        expect(CompactionChatResponseContent.is(content)).to.equal(true);
+        const compaction = content as CompactionChatResponseContent;
+        expect(compaction.provider).to.equal('anthropic');
+        expect(compaction.data).to.deep.equal({ b: 1 });
+        expect(compaction.summary).to.equal('s');
+    });
+});
+
+describe('AbstractChatAgent.getLanguageModelForRequest', () => {
+
+    const DEFAULT_MODEL = 'default-model';
+    const OVERRIDE_MODEL = 'override-model';
+
+    let agent: TestChatAgent;
+    let requestedIdentifiers: (string | undefined)[];
+
+    function fakeModel(id: string): LanguageModel {
+        return { id } as LanguageModel;
+    }
+
+    beforeEach(() => {
+        agent = new TestChatAgent();
+        agent.languageModelRequirements.push({ purpose: 'chat', identifier: DEFAULT_MODEL });
+        requestedIdentifiers = [];
+        // Resolve any of the known model ids; anything else (e.g. an unavailable override) resolves to undefined.
+        const known = new Set([DEFAULT_MODEL, OVERRIDE_MODEL]);
+        agent.setLanguageModelRegistry({
+            // Settings-aware selection used for the agent default (fallback) path.
+            async selectLanguageModel(request: LanguageModelSelector): Promise<LanguageModel | undefined> {
+                requestedIdentifiers.push(request.identifier);
+                return request.identifier && known.has(request.identifier) ? fakeModel(request.identifier) : undefined;
+            },
+            // Direct resolution used for the per-session override path (bypasses agent settings).
+            async getReadyLanguageModel(idOrAlias: string): Promise<LanguageModel | undefined> {
+                requestedIdentifiers.push(idOrAlias);
+                return known.has(idOrAlias) ? fakeModel(idOrAlias) : undefined;
+            }
+        } as unknown as LanguageModelRegistry);
+    });
+
+    function createRequest(modelOverride?: string): MutableChatRequestModel {
+        const model = new MutableChatModel(ChatAgentLocation.Panel);
+        const request = model.addRequest(createParsedRequest('Hello'));
+        if (modelOverride !== undefined) {
+            model.setSettings({ commonSettings: { modelId: modelOverride } });
+        }
+        return request;
+    }
+
+    it('uses the agent default when no session override is set', async () => {
+        const resolved = await agent.exposeGetLanguageModelForRequest(createRequest());
+        expect(resolved.id).to.equal(DEFAULT_MODEL);
+    });
+
+    it('honors the session model override when it resolves', async () => {
+        const resolved = await agent.exposeGetLanguageModelForRequest(createRequest(OVERRIDE_MODEL));
+        expect(resolved.id).to.equal(OVERRIDE_MODEL);
+        // The override id must be the first thing tried.
+        expect(requestedIdentifiers[0]).to.equal(OVERRIDE_MODEL);
+    });
+
+    it('falls back to the agent default when the session override does not resolve', async () => {
+        const resolved = await agent.exposeGetLanguageModelForRequest(createRequest('no-such-model'));
+        expect(resolved.id).to.equal(DEFAULT_MODEL);
+        // First the unavailable override is attempted, then the agent default.
+        expect(requestedIdentifiers).to.deep.equal(['no-such-model', DEFAULT_MODEL]);
+    });
+
+    it('throws when neither the override nor the default resolves', async () => {
+        agent.languageModelRequirements.length = 0;
+        agent.languageModelRequirements.push({ purpose: 'chat', identifier: 'missing-default' });
+        let error: Error | undefined;
+        try {
+            await agent.exposeGetLanguageModelForRequest(createRequest('also-missing'));
+        } catch (e) {
+            error = e as Error;
+        }
+        expect(error).to.be.an('error');
+    });
+});

package/src/common/chat-agents.ts

@@ -27,6 +27,7 @@ import {
     CapabilityAwareContext,
     GenericCapabilitySelections,
     getTextOfResponse,
+    isCompactionResponsePart,
     isLanguageModelStreamResponsePart,
     isServerToolCallResponsePart,
     isTextResponsePart,
@@ -51,6 +52,7 @@ import {
 } from '@theia/ai-core';
 import {
     Agent,
+    FrontendLanguageModelRegistry,
     isLanguageModelParsedResponse,
     isLanguageModelStreamResponse,
     isLanguageModelTextResponse,
@@ -65,6 +67,7 @@ import {
     ChatRequestModel,
     ChatResponseContent,
     CommonChatSessionSettings,
+    CompactionChatResponseContentImpl,
     ErrorChatResponseContentImpl,
     MarkdownChatResponseContentImpl,
     MutableChatRequestModel,
@@ -225,10 +228,12 @@ export abstract class AbstractChatAgent implements ChatAgent {
 
     async invoke(request: MutableChatRequestModel): Promise<void> {
         try {
-            const languageModel = await this.getLanguageModel(this.defaultLanguageModelPurpose);
+            const languageModel = await this.getLanguageModelForRequest(request, this.defaultLanguageModelPurpose);
             if (!languageModel) {
                 throw new Error(nls.localize('theia/ai/chat/couldNotFindMatchingLM', 'Couldn\'t find a matching language model. Please check your setup!'));
             }
+            // Record the model that actually handled this request so the chat thread can show it.
+            request.response.setLanguageModel(languageModel.id);
             const context: ChatSessionContext = {
                 model: request.session,
                 request,
@@ -313,6 +318,36 @@ export abstract class AbstractChatAgent implements ChatAgent {
         return this.selectLanguageModel(this.getLanguageModelSelector(languageModelPurpose));
     }
 
+    /**
+     * Resolves the language model for a request, honoring a per-session model override
+     * ({@link CommonChatSessionSettings.modelId}) when set and resolvable, and otherwise falling
+     * back to the agent's configured model for the given purpose.
+     */
+    protected async getLanguageModelForRequest(request: MutableChatRequestModel, languageModelPurpose: string): Promise<LanguageModel> {
+        const overrideId = request.session.settings?.commonSettings?.modelId;
+        if (overrideId) {
+            // Resolve the override directly. We must not go through `selectLanguageModel` here, because
+            // that honors the per-agent model configured in the AI settings, which would take
+            // precedence over and thus ignore the session override.
+            const overridden = await this.resolveModelById(overrideId);
+            if (overridden) {
+                return overridden;
+            }
+        }
+        return this.getLanguageModel(languageModelPurpose);
+    }
+
+    /** Resolves a concrete language model (or alias) id to a ready model, or `undefined` if none is ready. */
+    protected async resolveModelById(modelId: string): Promise<LanguageModel | undefined> {
+        const registry = this.languageModelRegistry as LanguageModelRegistry & Partial<FrontendLanguageModelRegistry>;
+        if (typeof registry.getReadyLanguageModel === 'function') {
+            // Frontend registry: resolves aliases and only returns the model if it is ready.
+            return registry.getReadyLanguageModel(modelId);
+        }
+        const model = await registry.getLanguageModel(modelId);
+        return model?.status.status === 'ready' ? model : undefined;
+    }
+
     protected async selectLanguageModel(selector: LanguageModelRequirement): Promise<LanguageModel> {
         const languageModel = await this.languageModelRegistry.selectLanguageModel({ agent: this.id, ...selector });
         if (!languageModel) {
@@ -547,6 +582,7 @@ export abstract class AbstractChatAgent implements ChatAgent {
                 serverTools: enabledServerTools.length > 0 ? enabledServerTools : undefined,
                 settings,
                 reasoning: commonSettings?.reasoning,
+                compaction: commonSettings?.compaction,
                 agentId: this.id,
                 sessionId: request.session.id,
                 requestId: request.id,
@@ -776,6 +812,13 @@ export abstract class AbstractStreamParsingChatAgent extends AbstractChatAgent {
             request.response.setTokenUsage(this.mapUsageResponsePart(token));
             return [];
         }
+        if (isCompactionResponsePart(token)) {
+            return new CompactionChatResponseContentImpl(
+                token.compaction.provider,
+                token.compaction.data,
+                token.compaction.summary
+            );
+        }
         return this.defaultContentFactory.create('', request);
     }
 

package/src/common/chat-auto-save.spec.ts

@@ -25,7 +25,7 @@ import { ILogger } from '@theia/core';
 import { ChatAgentLocation } from './chat-agents';
 import { ChatContentDeserializerRegistry, ChatContentDeserializerRegistryImpl, DefaultChatContentDeserializerContribution } from './chat-content-deserializer';
 import { ChangeSetElementDeserializerRegistry, ChangeSetElementDeserializerRegistryImpl } from './change-set-element-deserializer';
-import { ChatModel } from './chat-model';
+import { ChatModel, MutableChatModel } from './chat-model';
 import { SerializedChatData } from './chat-model-serialization';
 import { ParsedChatRequest, ParsedChatRequestTextPart } from './parsed-chat-request';
 
@@ -242,6 +242,23 @@ describe('Chat Auto-Save Mechanism', () => {
         });
     });
 
+    describe('Auto-save on settings changes', () => {
+        it('should auto-save when per-session settings change', async () => {
+            const session = chatService.createSession(ChatAgentLocation.Panel);
+            // Non-empty session so saveSession does not skip it.
+            await chatService.sendRequest(session.id, { text: 'Test request' });
+            sessionStore.reset();
+
+            // A selector-only / dialog-only settings change must trigger persistence.
+            (session.model as MutableChatModel).setSettings({ commonSettings: { modelId: 'test/model' } });
+
+            // Wait for auto-save to complete (debounce is 500ms + execution time)
+            await new Promise(resolve => setTimeout(resolve, 700));
+
+            expect(sessionStore.saveCount).to.be.greaterThan(0);
+        });
+    });
+
     describe('Auto-save for all sessions', () => {
         it('should save all non-empty sessions', async () => {
             const session1 = chatService.createSession(ChatAgentLocation.Panel);