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

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);

package/src/common/chat-content-deserializer.ts

@@ -19,6 +19,8 @@ import {
     ChatResponseContent,
     CodeChatResponseContentImpl,
     CommandChatResponseContentImpl,
+    CompactionChatResponseContentImpl,
+    CompactionContentData,
     ErrorChatResponseContentImpl,
     HorizontalLayoutChatResponseContentImpl,
     InformationalChatResponseContentImpl,
@@ -250,6 +252,15 @@ export class DefaultChatContentDeserializerContribution implements ChatContentDe
             )
         });
 
+        registry.register({
+            kind: 'compaction',
+            deserialize: (data: CompactionContentData) => new CompactionChatResponseContentImpl(
+                data.provider,
+                data.data,
+                data.summary
+            )
+        });
+
         registry.register({
             kind: 'markdownContent',
             deserialize: (data: MarkdownContentData) => new MarkdownChatResponseContentImpl(data.content)

package/src/common/chat-model-serialization.spec.ts

@@ -700,4 +700,42 @@ describe('ChatModel Serialization and Restoration', () => {
             expect(restoredPart.resolution?.variable.description).to.equal('File variable');
         });
     });
+
+    describe('Session settings and response model serialization', () => {
+        it('should serialize and restore the per-session model override', () => {
+            const model = new MutableChatModel(ChatAgentLocation.Panel);
+            model.addRequest(createParsedRequest('Hello'));
+            model.setSettings({ commonSettings: { modelId: 'anthropic/claude-opus-4-8' } });
+
+            const serialized = model.toSerializable();
+            expect(serialized.settings?.commonSettings?.modelId).to.equal('anthropic/claude-opus-4-8');
+
+            const restored = new MutableChatModel(serialized);
+            expect(restored.settings?.commonSettings?.modelId).to.equal('anthropic/claude-opus-4-8');
+        });
+
+        it('should leave settings undefined when none were set', () => {
+            const model = new MutableChatModel(ChatAgentLocation.Panel);
+            model.addRequest(createParsedRequest('Hello'));
+
+            const serialized = model.toSerializable();
+            expect(serialized.settings).to.be.undefined;
+
+            const restored = new MutableChatModel(serialized);
+            expect(restored.settings).to.be.undefined;
+        });
+
+        it('should serialize and restore the language model recorded on a response', () => {
+            const model = new MutableChatModel(ChatAgentLocation.Panel);
+            const request = model.addRequest(createParsedRequest('Hello'));
+            request.response.setLanguageModel('anthropic/claude-opus-4-8');
+            request.response.complete();
+
+            const serialized = model.toSerializable();
+            expect(serialized.responses[0].languageModel).to.equal('anthropic/claude-opus-4-8');
+
+            const restored = new MutableChatModel(serialized);
+            expect(restored.getAllRequests()[0].response.languageModel).to.equal('anthropic/claude-opus-4-8');
+        });
+    });
 });

package/src/common/chat-model-serialization.ts

@@ -16,7 +16,7 @@
 
 import { GenericCapabilitySelections } from '@theia/ai-core';
 import { ChatAgentLocation } from './chat-agents';
-import { ResponseTokenUsage } from './chat-model';
+import { ChatSessionSettings, ResponseTokenUsage } from './chat-model';
 
 export interface SerializableChangeSetElement {
     kind?: string;
@@ -138,6 +138,8 @@ export interface SerializableChatResponseData {
     errorMessage?: string;
     promptVariantId?: string;
     isPromptVariantEdited?: boolean;
+    /** Identifier of the language model that produced this response, if recorded. */
+    languageModel?: string;
     tokenUsage?: ResponseTokenUsage;
     content: SerializableChatResponseContentData[];
 }
@@ -189,6 +191,11 @@ export interface SerializedChatModel {
     requests: SerializableChatRequestData[];
     /** All responses for the requests */
     responses: SerializableChatResponseData[];
+    /**
+     * Per-session settings (e.g. the per-session model override) so they survive a reload and the
+     * chat input can restore the correct selection.
+     */
+    settings?: ChatSessionSettings;
 }
 
 /**
@@ -201,6 +208,10 @@ export interface SerializedChatData {
     title?: string;
     model: SerializedChatModel;
     saveDate: number;
+    /** ID of the root session in the delegation chain. */
+    rootSessionId?: string;
+    /** ID of the immediate parent session that delegated this one. */
+    parentSessionId?: string;
 }
 
 export interface SerializableChatsData {

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

@@ -0,0 +1,42 @@
+// *****************************************************************************
+// 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 { expect } from 'chai';
+import { CompactionChatResponseContentImpl, CompactionChatResponseContent } from './chat-model';
+
+describe('CompactionChatResponseContent', () => {
+    it('round-trips through serialization', () => {
+        const original = new CompactionChatResponseContentImpl('anthropic', { block: 'opaque' }, 'summary text');
+        const serialized = original.toSerializable();
+        expect(serialized.kind).to.equal('compaction');
+        const restored = new CompactionChatResponseContentImpl(
+            serialized.data.provider, serialized.data.data, serialized.data.summary);
+        expect(restored.provider).to.equal('anthropic');
+        expect(restored.summary).to.equal('summary text');
+        expect(restored.data).to.deep.equal({ block: 'opaque' });
+    });
+    it('produces a compaction language model message', () => {
+        const content = new CompactionChatResponseContentImpl('openai-responses', { item: 'x' });
+        const message = content.toLanguageModelMessage();
+        expect(message).to.deep.equal({ actor: 'ai', type: 'compaction', provider: 'openai-responses', data: { item: 'x' }, summary: undefined });
+    });
+    it('is excluded from plain-text history but offers a display string', () => {
+        const content = new CompactionChatResponseContentImpl('anthropic', {}, 'sum');
+        expect(content.asString()).to.equal(undefined);
+        expect(content.asDisplayString()).to.equal('sum');
+        expect(CompactionChatResponseContent.is(content)).to.equal(true);
+    });
+});