@theia/ai-chat 1.76.0-next.6 → 1.76.0

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

@@ -15,7 +15,15 @@
 // *****************************************************************************
 
 import { expect } from 'chai';
-import { MarkdownChatResponseContentImpl, MutableChatResponseModel, ToolCallChatResponseContentImpl } from './chat-model';
+import {
+    ChatResponseContent,
+    InteractiveContent,
+    MarkdownChatResponseContentImpl,
+    MutableChatRequestModel,
+    MutableChatResponseModel,
+    QuestionResponseContentImpl,
+    ToolCallChatResponseContentImpl
+} from './chat-model';
 
 describe('MutableChatResponseModel', () => {
     describe('content change propagation', () => {
@@ -190,4 +198,207 @@ describe('MutableChatResponseModel', () => {
             expect(response.isWaitingForInput).to.equal(false);
         });
     });
+
+    describe('pending interactions', () => {
+        const createAwaitingToolCall = (id: string): ToolCallChatResponseContentImpl => {
+            const toolCall = new ToolCallChatResponseContentImpl(id, 'tool', '{}', false);
+            toolCall.requestUserConfirmation();
+            return toolCall;
+        };
+
+        it('should track a content part fired via fireInteractionNeeded until it is resolved', async () => {
+            const response = new MutableChatResponseModel('req-1');
+            const toolCall = createAwaitingToolCall('tool-1');
+            response.response.addContent(toolCall);
+
+            expect(response.pendingInteractions).to.have.lengthOf(0);
+
+            response.fireInteractionNeeded(toolCall);
+
+            // Late subscribers (e.g. a remounted delegation renderer) must be able to
+            // rebuild pending interaction state instead of relying on the push event.
+            expect(response.pendingInteractions).to.deep.equal([toolCall]);
+
+            toolCall.complete('done');
+            await toolCall.whenResolved;
+
+            expect(response.pendingInteractions).to.have.lengthOf(0);
+        });
+
+        it('should not track the same interaction twice', () => {
+            const response = new MutableChatResponseModel('req-1');
+            const toolCall = createAwaitingToolCall('tool-1');
+            response.response.addContent(toolCall);
+
+            response.fireInteractionNeeded(toolCall);
+            response.fireInteractionNeeded(toolCall);
+
+            expect(response.pendingInteractions).to.have.lengthOf(1);
+        });
+
+        it('should still emit onInteractionNeeded for every fireInteractionNeeded call', () => {
+            const response = new MutableChatResponseModel('req-1');
+            const toolCall = createAwaitingToolCall('tool-1');
+            response.response.addContent(toolCall);
+
+            let fireCount = 0;
+            response.onInteractionNeeded(() => { fireCount++; });
+
+            response.fireInteractionNeeded(toolCall);
+            response.fireInteractionNeeded(toolCall);
+
+            expect(fireCount).to.equal(2);
+        });
+
+        it('should clear pending interactions on complete()', () => {
+            const response = new MutableChatResponseModel('req-1');
+            const toolCall = createAwaitingToolCall('tool-1');
+            response.response.addContent(toolCall);
+            response.fireInteractionNeeded(toolCall);
+
+            response.complete();
+
+            expect(response.pendingInteractions).to.have.lengthOf(0);
+        });
+
+        it('should clear pending interactions on cancel()', () => {
+            const response = new MutableChatResponseModel('req-1');
+            const toolCall = createAwaitingToolCall('tool-1');
+            // cancel() rejects the tool call's confirmed promise; absorb the rejection
+            // so it does not surface as an unhandled rejection in stricter runners.
+            toolCall.confirmed.catch(() => { /* expected rejection */ });
+            response.response.addContent(toolCall);
+            response.fireInteractionNeeded(toolCall);
+
+            response.cancel();
+
+            expect(response.pendingInteractions).to.have.lengthOf(0);
+        });
+
+        it('should not track interactions fired after the response completed', () => {
+            const response = new MutableChatResponseModel('req-1');
+            const toolCall = createAwaitingToolCall('tool-1');
+            response.response.addContent(toolCall);
+            response.complete();
+
+            // e.g. a bubbled child-session interaction arriving after the parent finished
+            response.fireInteractionNeeded(toolCall);
+
+            expect(response.pendingInteractions).to.have.lengthOf(0);
+        });
+
+        it('should not list a confirmed tool call that is still executing', () => {
+            const response = new MutableChatResponseModel('req-1');
+            const toolCall = createAwaitingToolCall('tool-1');
+            response.response.addContent(toolCall);
+            response.fireInteractionNeeded(toolCall);
+
+            toolCall.confirm();
+
+            // The confirmation was granted; the tool is executing but no longer actionable
+            // by the user, so late subscribers must not resurrect the confirmation UI.
+            expect(response.pendingInteractions).to.have.lengthOf(0);
+        });
+
+        it('should not list a tool call whose confirmation was canceled', () => {
+            const response = new MutableChatResponseModel('req-1');
+            const toolCall = createAwaitingToolCall('tool-1');
+            response.response.addContent(toolCall);
+            response.fireInteractionNeeded(toolCall);
+            toolCall.confirmed.catch(() => { /* expected rejection */ });
+
+            toolCall.cancelConfirmation(new Error('canceled'));
+
+            expect(response.pendingInteractions).to.have.lengthOf(0);
+        });
+
+        it('should list a tool call waiting for user input until the input is handled', () => {
+            const response = new MutableChatResponseModel('req-1');
+            const toolCall = new ToolCallChatResponseContentImpl('tool-1', 'tool', '{}', false);
+            response.response.addContent(toolCall);
+
+            toolCall.requestUserInput();
+            response.fireInteractionNeeded(toolCall);
+            expect(response.pendingInteractions).to.deep.equal([toolCall]);
+
+            toolCall.userInputHandled();
+            expect(response.pendingInteractions).to.have.lengthOf(0);
+        });
+
+        it('should stop tracking a content part whose whenResolved rejects', async () => {
+            const response = new MutableChatResponseModel('req-1');
+            let reject!: (reason?: unknown) => void;
+            const whenResolved = new Promise<void>((_, rej) => { reject = rej; });
+            const contentPart = {
+                kind: 'markdown',
+                interactionId: 'rejecting',
+                isResolved: false,
+                isAwaitingInteraction: true,
+                whenResolved
+            } as unknown as InteractiveContent & ChatResponseContent;
+
+            response.fireInteractionNeeded(contentPart);
+            expect(response.pendingInteractions).to.deep.equal([contentPart]);
+
+            // Custom InteractiveContent implementations may reject whenResolved; the model
+            // must still stop tracking the part and must not raise an unhandled rejection.
+            reject(new Error('interaction aborted'));
+            await whenResolved.catch(() => { /* expected rejection */ });
+
+            expect(response.pendingInteractions).to.have.lengthOf(0);
+        });
+    });
+
+    describe('interactive content awaiting state', () => {
+        it('tool call: isAwaitingInteraction follows confirmation and user-input state', () => {
+            const toolCall = new ToolCallChatResponseContentImpl('tool-1', 'tool', '{}', false);
+            expect(toolCall.isAwaitingInteraction).to.equal(false);
+
+            toolCall.requestUserConfirmation();
+            expect(toolCall.isAwaitingInteraction).to.equal(true);
+            toolCall.confirm();
+            expect(toolCall.isAwaitingInteraction).to.equal(false);
+
+            toolCall.requestUserInput();
+            expect(toolCall.isAwaitingInteraction).to.equal(true);
+            toolCall.userInputHandled();
+            expect(toolCall.isAwaitingInteraction).to.equal(false);
+        });
+
+        it('tool call: finishing clears the awaiting-input state', () => {
+            const toolCall = new ToolCallChatResponseContentImpl('tool-1', 'tool', '{}', false);
+            toolCall.requestUserInput();
+
+            toolCall.complete('done');
+
+            expect(toolCall.isAwaitingInteraction).to.equal(false);
+        });
+
+        it('question: isAwaitingInteraction is false once answered or skipped', () => {
+            const fakeRequest = {
+                response: {
+                    fireInteractionNeeded: () => { },
+                    response: { responseContentChanged: () => { } }
+                }
+            } as unknown as MutableChatRequestModel;
+            const options = [{ text: 'Yes', value: 'yes' }];
+
+            const answered = new QuestionResponseContentImpl('Proceed?', options, fakeRequest, () => { });
+            expect(answered.isAwaitingInteraction).to.equal(true);
+            answered.selectedOption = options[0];
+            expect(answered.isAwaitingInteraction).to.equal(false);
+
+            // A dismissed question resolves with an empty selection: isResolved stays
+            // false, but the question must no longer count as awaiting interaction.
+            const skipped = new QuestionResponseContentImpl('Proceed?', options, fakeRequest, () => { });
+            skipped.selectedOptions = [];
+            expect(skipped.isResolved).to.equal(false);
+            expect(skipped.isAwaitingInteraction).to.equal(false);
+        });
+
+        it('question: a read-only (restored) question is never awaiting interaction', () => {
+            const question = new QuestionResponseContentImpl('Proceed?', [{ text: 'Yes', value: 'yes' }], undefined, undefined);
+            expect(question.isAwaitingInteraction).to.equal(false);
+        });
+    });
 });

package/src/common/chat-service.ts

@@ -49,17 +49,36 @@ import debounce = require('@theia/core/shared/lodash.debounce');
 // Re-export for backward compatibility
 export { DefaultChatAgentId, FallbackChatAgentId };
 
+/**
+ * Error with which {@link ChatRequestInvocation.requestCompleted} and
+ * {@link ChatRequestInvocation.responseCreated} are rejected when no chat agent is available
+ * to handle the request.
+ */
+export class NoChatAgentError extends Error {
+    constructor(message: string) {
+        super(message);
+        this.name = 'NoChatAgentError';
+    }
+
+    static is(error: unknown): error is NoChatAgentError {
+        return error instanceof Error && error.name === 'NoChatAgentError';
+    }
+}
+
 export interface ChatRequestInvocation {
     /**
      * Promise which completes once the request preprocessing is complete.
+     * Rejected with a {@link NoChatAgentError} when no agent is available to handle the request.
      */
     requestCompleted: Promise<ChatRequestModel>;
     /**
      * Promise which completes once a response is expected to arrive.
+     * Rejected with a {@link NoChatAgentError} when no agent is available to handle the request.
      */
     responseCreated: Promise<ChatResponseModel>;
     /**
      * Promise which completes once the response is complete.
+     * In the no-agent case it resolves with the error response model instead of rejecting.
      */
     responseCompleted: Promise<ChatResponseModel>;
 }
@@ -341,14 +360,18 @@ export class ChatServiceImpl implements ChatService {
         session.pinnedAgent = agent;
 
         if (agent === undefined) {
-            const error = 'No agent was found to handle this request. ' +
+            const error = new NoChatAgentError('No agent was found to handle this request. ' +
                 'Please ensure you have configured a default agent in the preferences and that the agent is enabled in the AI Configuration view. ' +
-                'Alternatively, mention a specific agent with @AgentName.';
-            this.logger.error(error);
-            const chatResponseModel = new ErrorChatResponseModel(generateUuid(), new Error(error));
+                'Alternatively, mention a specific agent with @AgentName.');
+            this.logger.error(error.message);
+            const chatResponseModel = new ErrorChatResponseModel(generateUuid(), error);
+            // share one handled rejection so that consumers awaiting only one of the
+            // promises do not trigger unhandled rejection reports for the other
+            const rejected = Promise.reject<never>(error);
+            rejected.catch(() => { });
             return {
-                requestCompleted: Promise.reject(error),
-                responseCreated: Promise.reject(error),
+                requestCompleted: rejected,
+                responseCreated: rejected,
                 responseCompleted: Promise.resolve(chatResponseModel),
             };
         }