@theia/ai-chat 1.71.0-next.8 → 1.71.0

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

@@ -16,6 +16,7 @@
 
 import { GenericCapabilitySelections } from '@theia/ai-core';
 import { ChatAgentLocation } from './chat-agents';
+import { ResponseTokenUsage } from './chat-model';
 
 export interface SerializableChangeSetElement {
     kind?: string;
@@ -129,6 +130,7 @@ export interface SerializableChatResponseData {
     errorMessage?: string;
     promptVariantId?: string;
     isPromptVariantEdited?: boolean;
+    tokenUsage?: ResponseTokenUsage;
     content: SerializableChatResponseContentData[];
 }
 

package/src/common/chat-model.ts

@@ -23,11 +23,11 @@ import {
     AIVariableResolutionRequest,
     GenericCapabilitySelections,
     LanguageModelMessage,
+    ReasoningSettings,
     ResolvedAIContextVariable,
     ResolvedAIVariable,
     TextMessage,
     ThinkingMessage,
-    ThinkingModeSettings,
     ToolCallResult,
     ToolRequest,
     ToolResultMessage,
@@ -78,7 +78,8 @@ export type ChatChangeEvent =
     | ChatEditCancelEvent
     | ChatEditSubmitEvent
     | ChatResponseChangedEvent
-    | ChatChangeHierarchyBranchEvent;
+    | ChatChangeHierarchyBranchEvent
+    | ChatInteractionNeededEvent;
 
 export interface ChatAddRequestEvent {
     kind: 'addRequest';
@@ -135,10 +136,18 @@ export interface ChatResponseChangedEvent {
     kind: 'responseChanged';
 }
 
+export interface ChatInteractionNeededEvent {
+    kind: 'interactionNeeded';
+    contentPart: InteractiveContent & ChatResponseContent;
+}
+
 export namespace ChatChangeEvent {
     export function isChangeSetEvent(event: ChatChangeEvent): event is ChatUpdateChangeSetEvent {
         return event.kind === 'updateChangeSet';
     }
+    export function isInteractionNeededEvent(event: ChatChangeEvent): event is ChatInteractionNeededEvent {
+        return event.kind === 'interactionNeeded';
+    }
 }
 
 export type ChatRequestRemovalReason = 'removal' | 'resend' | 'adoption';
@@ -212,11 +221,8 @@ export interface ChatHierarchyBranchItem<TRequest extends ChatRequestModel = Cha
 }
 
 export interface CommonChatSessionSettings {
-    /**
-     * Theia-specific settings for extended thinking mode.
-     * These are processed by Theia and converted to provider-specific formats.
-     */
-    thinkingMode?: ThinkingModeSettings;
+    /** Reasoning configuration for this session; applied to reasoning-capable models. */
+    reasoning?: ReasoningSettings;
     /** Per-session tool confirmation timeout in seconds. Overrides the global preference when set. */
     confirmationTimeout?: number;
 }
@@ -382,6 +388,29 @@ export interface ChatProgressMessage {
     content: string;
 }
 
+/**
+ * Interface for ChatResponseContent parts that require user interaction.
+ * Content parts that implement this interface can be tracked by the delegation
+ * renderer without content-type-specific checks.
+ */
+export interface InteractiveContent {
+    /** Stable identifier for deduplication in pending interaction tracking. */
+    readonly interactionId: string | undefined;
+    /** Whether the interaction has been resolved (e.g., confirmed/denied, option selected). */
+    readonly isResolved: boolean;
+    /** Resolves when the interaction is resolved. Used for cleanup in delegation chains. */
+    readonly whenResolved: Promise<void>;
+}
+
+export namespace InteractiveContent {
+    export function is(content: unknown): content is InteractiveContent {
+        return typeof content === 'object' && !!content
+            && 'interactionId' in content
+            && 'isResolved' in content
+            && 'whenResolved' in content;
+    }
+}
+
 export interface ChatResponseContent {
     kind: string;
     /**
@@ -526,7 +555,7 @@ export interface HorizontalLayoutChatResponseContent extends ChatResponseContent
     content: ChatResponseContent[];
 }
 
-export interface ToolCallChatResponseContent extends Required<ChatResponseContent> {
+export interface ToolCallChatResponseContent extends Required<ChatResponseContent>, InteractiveContent {
     kind: 'toolCall';
     id?: string;
     name?: string;
@@ -803,7 +832,7 @@ export type MultiSelectQuestionResponseHandler = (
     selectedOptions: { text: string, value?: string }[],
 ) => void;
 
-export interface QuestionResponseContent extends ChatResponseContent {
+export interface QuestionResponseContent extends ChatResponseContent, InteractiveContent {
     kind: 'question';
     question: string;
     header?: string;
@@ -844,6 +873,13 @@ export namespace QuestionResponseContent {
     }
 }
 
+export interface ResponseTokenUsage {
+    readonly inputTokens: number;
+    readonly outputTokens: number;
+    readonly cacheCreationInputTokens?: number;
+    readonly cacheReadInputTokens?: number;
+}
+
 export interface ChatResponse {
     readonly content: ChatResponseContent[];
     asString(): string;
@@ -858,6 +894,11 @@ export interface ChatResponseModel {
      * Use this to be notified for any change in the response model
      */
     readonly onDidChange: Event<void>;
+    /**
+     * Fires when this response requires user interaction (e.g., tool confirmation, question response).
+     * The content part that needs interaction is provided as the event payload.
+     */
+    readonly onInteractionNeeded: Event<InteractiveContent & ChatResponseContent>;
     /**
      * The unique identifier of the response model
      */
@@ -911,6 +952,7 @@ export interface ChatResponseModel {
      * Indicates whether the prompt variant was customized/edited
      */
     readonly isPromptVariantEdited?: boolean;
+    readonly tokenUsage?: ResponseTokenUsage;
     toSerializable(): SerializableChatResponseData;
 }
 
@@ -1052,6 +1094,17 @@ export class MutableChatModel implements ChatModel, Disposable {
         this._settings = settings;
     }
 
+    addChildModel(child: MutableChatModel): Disposable {
+        const disposable = new DisposableCollection();
+        disposable.push(child.onDidChange(event => {
+            if (ChatChangeEvent.isInteractionNeededEvent(event)) {
+                this._onDidChangeEmitter.fire(event);
+            }
+        }));
+        this.toDispose.push(disposable);
+        return disposable;
+    }
+
     addRequest(parsedChatRequest: ParsedChatRequest, agentId?: string, context: ChatContext = { variables: [] }): MutableChatRequestModel {
         const add = this.getTargetForRequestAddition(parsedChatRequest);
         const requestModel = new MutableChatRequestModel(
@@ -1680,10 +1733,14 @@ export class MutableChatRequestModel implements ChatRequestModel, EditableChatRe
 
         // Wire response changes to propagate through request to session
         this._response.onDidChange(() => {
-            // Fire a generic addVariable event to propagate response changes
             this._onDidChangeEmitter.fire({ kind: 'responseChanged' });
         }, this, this.toDispose);
 
+        // Wire interaction needed events to propagate through request to session
+        this._response.onInteractionNeeded(contentPart => {
+            this._onDidChangeEmitter.fire({ kind: 'interactionNeeded', contentPart });
+        }, this, this.toDispose);
+
         this.toDispose.push(this._onDidChangeEmitter);
     }
 
@@ -2236,7 +2293,7 @@ export class CodeChatResponseContentImpl implements CodeChatResponseContent {
     }
 }
 
-export class ToolCallChatResponseContentImpl implements ToolCallChatResponseContent {
+export class ToolCallChatResponseContentImpl implements ToolCallChatResponseContent, InteractiveContent {
     readonly kind = 'toolCall';
     protected _id?: string;
     protected _name?: string;
@@ -2298,6 +2355,14 @@ export class ToolCallChatResponseContentImpl implements ToolCallChatResponseCont
         this._confirmationTimeout = value;
     }
 
+    get interactionId(): string | undefined {
+        return this._id;
+    }
+
+    get isResolved(): boolean {
+        return this.finished;
+    }
+
     get confirmed(): Promise<boolean> {
         return this._confirmed;
     }
@@ -2310,6 +2375,10 @@ export class ToolCallChatResponseContentImpl implements ToolCallChatResponseCont
         return this._whenFinished;
     }
 
+    get whenResolved(): Promise<void> {
+        return this._whenFinished;
+    }
+
     createConfirmationPromise(): Promise<boolean> {
         if (!this._confirmationResolver) {
             this._confirmed = new Promise<boolean>((resolve, reject) => {
@@ -2563,12 +2632,14 @@ export interface QuestionResponseContentOptions {
  * Default implementation for the QuestionResponseContent.
  * Can be created with or without handler/request for read-only (restored) mode.
  */
-export class QuestionResponseContentImpl implements QuestionResponseContent {
+export class QuestionResponseContentImpl implements QuestionResponseContent, InteractiveContent {
     readonly kind = 'question';
     public multiSelect?: boolean;
     public header?: string;
     public onSkip?: () => void;
     protected _selectedOptions: { text: string; value?: string }[] | undefined;
+    protected _resolvedResolver?: () => void;
+    readonly whenResolved: Promise<void>;
 
     constructor(
         question: string,
@@ -2596,14 +2667,33 @@ export class QuestionResponseContentImpl implements QuestionResponseContent {
         this.onSkip = questionOptions?.onSkip;
         this._selectedOptions = questionOptions?.selectedOptions ??
             (questionOptions?.selectedOption ? [questionOptions.selectedOption] : undefined);
+        if (this._selectedOptions) {
+            this.whenResolved = Promise.resolve();
+        } else {
+            this.whenResolved = new Promise<void>(resolve => {
+                this._resolvedResolver = resolve;
+            });
+        }
+        if (!this.isReadOnly && this.request) {
+            this.request.response.fireInteractionNeeded(this);
+        }
     }
 
     get isReadOnly(): boolean {
         return !this.handler || !this.request;
     }
 
+    get interactionId(): string | undefined {
+        return `question-${this.question}`;
+    }
+
+    get isResolved(): boolean {
+        return this.selectedOption !== undefined;
+    }
+
     set selectedOption(option: { text: string; value?: string } | undefined) {
         this._selectedOptions = option ? [option] : undefined;
+        this._resolvedResolver?.();
         if (this.request) {
             this.request.response.response.responseContentChanged();
         }
@@ -2614,6 +2704,7 @@ export class QuestionResponseContentImpl implements QuestionResponseContent {
 
     set selectedOptions(options: { text: string; value?: string }[] | undefined) {
         this._selectedOptions = options;
+        this._resolvedResolver?.();
         if (this.request) {
             this.request.response.response.responseContentChanged();
         }
@@ -2766,6 +2857,9 @@ export class MutableChatResponseModel implements ChatResponseModel {
     protected readonly _onDidChangeEmitter = new Emitter<void>();
     onDidChange: Event<void> = this._onDidChangeEmitter.event;
 
+    protected readonly _onInteractionNeededEmitter = new Emitter<InteractiveContent & ChatResponseContent>();
+    readonly onInteractionNeeded: Event<InteractiveContent & ChatResponseContent> = this._onInteractionNeededEmitter.event;
+
     data = {};
 
     protected _id: string;
@@ -2780,6 +2874,8 @@ export class MutableChatResponseModel implements ChatResponseModel {
     protected _cancellationToken: CancellationTokenSource;
     protected _promptVariantId?: string;
     protected _isPromptVariantEdited?: boolean;
+    protected _tokenUsage?: ResponseTokenUsage;
+    protected _tokenUsageEntries: ResponseTokenUsage[] = [];
 
     constructor(
         requestId: string,
@@ -2823,6 +2919,7 @@ export class MutableChatResponseModel implements ChatResponseModel {
         this._progressMessages = [];
         this._promptVariantId = data.promptVariantId;
         this._isPromptVariantEdited = data.isPromptVariantEdited ?? false;
+        this._tokenUsage = data.tokenUsage;
 
         if (data.errorMessage) {
             this._errorObject = new Error(data.errorMessage);
@@ -2902,6 +2999,24 @@ export class MutableChatResponseModel implements ChatResponseModel {
         return this._isPromptVariantEdited ?? false;
     }
 
+    get tokenUsage(): ResponseTokenUsage | undefined {
+        return this._tokenUsage;
+    }
+
+    setTokenUsage(usage: ResponseTokenUsage): void {
+        this._tokenUsage = usage;
+        this.addTokenUsageEntry(usage);
+        this._onDidChangeEmitter.fire();
+    }
+
+    addTokenUsageEntry(usage: ResponseTokenUsage): void {
+        this._tokenUsageEntries.push(usage);
+    }
+
+    get tokenUsageEntries(): readonly ResponseTokenUsage[] {
+        return this._tokenUsageEntries;
+    }
+
     setPromptVariantInfo(variantId: string | undefined, isEdited: boolean): void {
         this._promptVariantId = variantId;
         this._isPromptVariantEdited = isEdited;
@@ -2952,6 +3067,14 @@ export class MutableChatResponseModel implements ChatResponseModel {
         this._onDidChangeEmitter.fire();
     }
 
+    fireInteractionNeeded(contentPart: InteractiveContent & ChatResponseContent): void {
+        this._onInteractionNeededEmitter.fire(contentPart);
+    }
+
+    notifyChanged(): void {
+        this._onDidChangeEmitter.fire();
+    }
+
     error(error: Error): void {
         this._isComplete = true;
         this._isWaitingForInput = false;
@@ -2975,6 +3098,7 @@ export class MutableChatResponseModel implements ChatResponseModel {
             errorMessage: this.errorObject?.message,
             promptVariantId: this._promptVariantId,
             isPromptVariantEdited: this._isPromptVariantEdited,
+            tokenUsage: this._tokenUsage,
             content: this.response.content.map(c => {
                 const serialized = c.toSerializable?.();
                 if (!serialized) {

package/src/common/chat-request-parser.spec.ts

@@ -323,6 +323,9 @@ describe('ChatRequestParserImpl', () => {
             invoke: async () => undefined,
         });
 
+        // Set up the parser's agent service so it can recognise agents during parsing
+        chatAgentService.getAgents.returns([createAgent('agentA'), createAgent('agentB')]);
+
         const tool = new AgentDelegationTool();
         (tool as unknown as { getChatAgentService: () => unknown }).getChatAgentService = () => ({
             getAgent: sinon.stub().withArgs('agentA').returns(createAgent('agentA')),
@@ -348,11 +351,12 @@ describe('ChatRequestParserImpl', () => {
                 id: 'session-1',
                 model: {
                     changeSet: {
-                        onDidChange: sinon.stub().returns({}),
+                        onDidChange: sinon.stub().returns({ dispose: sinon.stub() }),
                         getElements: sinon.stub().returns([]),
                         setTitle: sinon.stub(),
                         addElements: sinon.stub(),
-                    }
+                    },
+                    onDidChange: sinon.stub().returns({ dispose: sinon.stub() })
                 }
             }),
             sendRequest,

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

@@ -0,0 +1,47 @@
+// *****************************************************************************
+// 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 { MutableChatResponseModel } from './chat-model';
+
+describe('MutableChatResponseModel', () => {
+    describe('setTokenUsage', () => {
+        it('should also add a token usage entry', () => {
+            const response = new MutableChatResponseModel('req-1');
+            const usage = { inputTokens: 100, outputTokens: 50 };
+
+            response.setTokenUsage(usage);
+
+            expect(response.tokenUsage).to.deep.equal(usage);
+            expect(response.tokenUsageEntries).to.have.lengthOf(1);
+            expect(response.tokenUsageEntries[0]).to.deep.equal(usage);
+        });
+
+        it('should accumulate entries across multiple setTokenUsage calls', () => {
+            const response = new MutableChatResponseModel('req-1');
+            const usage1 = { inputTokens: 100, outputTokens: 50 };
+            const usage2 = { inputTokens: 200, outputTokens: 80 };
+
+            response.setTokenUsage(usage1);
+            response.setTokenUsage(usage2);
+
+            expect(response.tokenUsage).to.deep.equal(usage2);
+            expect(response.tokenUsageEntries).to.have.lengthOf(2);
+            expect(response.tokenUsageEntries[0]).to.deep.equal(usage1);
+            expect(response.tokenUsageEntries[1]).to.deep.equal(usage2);
+        });
+    });
+});