@theia/ai-chat 1.55.1 → 1.57.0-next.112

package/src/browser/change-set-file-service.ts

@@ -0,0 +1,136 @@
+// *****************************************************************************
+// Copyright (C) 2025 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 { ILogger, UNTITLED_SCHEME, URI } from '@theia/core';
+import { DiffUris, LabelProvider, OpenerService, open } from '@theia/core/lib/browser';
+import { inject, injectable } from '@theia/core/shared/inversify';
+import { EditorManager } from '@theia/editor/lib/browser';
+import { FileService } from '@theia/filesystem/lib/browser/file-service';
+import { MonacoWorkspace } from '@theia/monaco/lib/browser/monaco-workspace';
+import { WorkspaceService } from '@theia/workspace/lib/browser/workspace-service';
+import { ChangeSetFileElement } from './change-set-file-element';
+
+@injectable()
+export class ChangeSetFileService {
+    @inject(ILogger)
+    protected readonly logger: ILogger;
+
+    @inject(WorkspaceService)
+    protected readonly wsService: WorkspaceService;
+
+    @inject(LabelProvider)
+    protected readonly labelProvider: LabelProvider;
+
+    @inject(OpenerService)
+    protected readonly openerService: OpenerService;
+
+    @inject(EditorManager)
+    protected readonly editorManager: EditorManager;
+
+    @inject(MonacoWorkspace)
+    protected readonly monacoWorkspace: MonacoWorkspace;
+
+    @inject(FileService)
+    protected readonly fileService: FileService;
+
+    async read(uri: URI): Promise<string | undefined> {
+        const exists = await this.fileService.exists(uri);
+        if (!exists) {
+            return undefined;
+        }
+        try {
+            const document = this.monacoWorkspace.getTextDocument(uri.toString());
+            if (document) {
+                return document.getText();
+            }
+            return (await this.fileService.readFile(uri)).value.toString();
+        } catch (error) {
+            this.logger.error('Failed to read original content of change set file element.', error);
+            return undefined;
+        }
+    }
+
+    getName(uri: URI): string {
+        return this.labelProvider.getName(uri);
+    }
+
+    getIcon(uri: URI): string | undefined {
+        return this.labelProvider.getIcon(uri);
+    }
+
+    getAdditionalInfo(uri: URI): string | undefined {
+        const wsUri = this.wsService.getWorkspaceRootUri(uri);
+        if (wsUri) {
+            const wsRelative = wsUri.relative(uri);
+            if (wsRelative?.hasDir) {
+                return `${wsRelative.dir.toString()}`;
+            }
+            return '';
+        }
+        return this.labelProvider.getLongName(uri.parent);
+    }
+
+    async open(element: ChangeSetFileElement): Promise<void> {
+        const exists = await this.fileService.exists(element.uri);
+        if (exists) {
+            await open(this.openerService, element.uri);
+            return;
+        }
+        await this.editorManager.open(element.changedUri, {
+            mode: 'reveal'
+        });
+    }
+
+    async openDiff(originalUri: URI, suggestedUri: URI): Promise<void> {
+        const exists = await this.fileService.exists(originalUri);
+        const openedUri = exists ? originalUri : originalUri.withScheme(UNTITLED_SCHEME);
+        // Currently we don't have a great way to show the suggestions in a diff editor with accept/reject buttons
+        // So we just use plain diffs with the suggestions as original and the current state as modified, so users can apply changes in their current state
+        // But this leads to wrong colors and wrong label (revert change instead of accept change)
+        const diffUri = DiffUris.encode(openedUri, suggestedUri,
+            `AI Changes: ${this.labelProvider.getName(originalUri)}`,
+        );
+        open(this.openerService, diffUri);
+    }
+
+    async delete(uri: URI): Promise<void> {
+        const exists = await this.fileService.exists(uri);
+        if (exists) {
+            await this.fileService.delete(uri);
+        }
+    }
+
+    async write(uri: URI, targetState: string): Promise<void> {
+        const exists = await this.fileService.exists(uri);
+        if (!exists) {
+            await this.fileService.create(uri, targetState);
+        }
+        await this.doWrite(uri, targetState);
+    }
+
+    protected async doWrite(uri: URI, text: string): Promise<void> {
+        const document = this.monacoWorkspace.getTextDocument(uri.toString());
+        if (document) {
+            await this.monacoWorkspace.applyBackgroundEdit(document, [{
+                range: document.textEditorModel.getFullModelRange(),
+                text
+            }], (editor, wasDirty) => editor === undefined || !wasDirty);
+        } else {
+            await this.fileService.write(uri, text);
+        }
+    }
+
+}

package/src/common/chat-agents.ts

@@ -38,12 +38,11 @@ import {
     LanguageModelStreamResponsePart,
     MessageActor,
 } from '@theia/ai-core/lib/common';
-import { CancellationToken, CancellationTokenSource, ContributionProvider, ILogger, isArray } from '@theia/core';
-import { inject, injectable, named, postConstruct } from '@theia/core/shared/inversify';
+import { CancellationToken, ContributionProvider, ILogger, isArray } from '@theia/core';
+import { inject, injectable, named, postConstruct, unmanaged } from '@theia/core/shared/inversify';
 import { ChatAgentService } from './chat-agent-service';
 import {
     ChatModel,
-    ChatRequestModel,
     ChatRequestModelImpl,
     ChatResponseContent,
     ErrorChatResponseContentImpl,
@@ -52,6 +51,8 @@ import {
 } from './chat-model';
 import { findFirstMatch, parseContents } from './parse-contents';
 import { DefaultResponseContentFactory, ResponseContentMatcher, ResponseContentMatcherProvider } from './response-content-matcher';
+import { ChatHistoryEntry } from './chat-history-entry';
+import { ChatToolRequestService } from './chat-tool-request-service';
 
 /**
  * A conversation consists of a sequence of ChatMessages.
@@ -122,28 +123,35 @@ export abstract class AbstractChatAgent {
     @inject(LanguageModelRegistry) protected languageModelRegistry: LanguageModelRegistry;
     @inject(ILogger) protected logger: ILogger;
     @inject(CommunicationRecordingService) protected recordingService: CommunicationRecordingService;
+    @inject(ChatToolRequestService) protected chatToolRequestService: ChatToolRequestService;
     @inject(PromptService) protected promptService: PromptService;
 
     @inject(ContributionProvider) @named(ResponseContentMatcherProvider)
     protected contentMatcherProviders: ContributionProvider<ResponseContentMatcherProvider>;
+    protected additionalToolRequests: ToolRequest[] = [];
     protected contentMatchers: ResponseContentMatcher[] = [];
 
     @inject(DefaultResponseContentFactory)
     protected defaultContentFactory: DefaultResponseContentFactory;
 
     constructor(
-        public id: string,
-        public languageModelRequirements: LanguageModelRequirement[],
-        protected defaultLanguageModelPurpose: string,
-        public iconClass: string = 'codicon codicon-copilot',
-        public locations: ChatAgentLocation[] = ChatAgentLocation.ALL,
-        public tags: String[] = ['Chat'],
-        public defaultLogging: boolean = true) {
+        @unmanaged() public id: string,
+        @unmanaged() public languageModelRequirements: LanguageModelRequirement[],
+        @unmanaged() protected defaultLanguageModelPurpose: string,
+        @unmanaged() public iconClass: string = 'codicon codicon-copilot',
+        @unmanaged() public locations: ChatAgentLocation[] = ChatAgentLocation.ALL,
+        @unmanaged() public tags: string[] = ['Chat'],
+        @unmanaged() public defaultLogging: boolean = true) {
     }
 
     @postConstruct()
     init(): void {
-        this.contentMatchers = this.contentMatcherProviders.getContributions().flatMap(provider => provider.matchers);
+        this.initializeContentMatchers();
+    }
+
+    protected initializeContentMatchers(): void {
+        const contributedContentMatchers = this.contentMatcherProviders.getContributions().flatMap(provider => provider.matchers);
+        this.contentMatchers.push(...contributedContentMatchers);
     }
 
     async invoke(request: ChatRequestModelImpl): Promise<void> {
@@ -152,20 +160,19 @@ export abstract class AbstractChatAgent {
             if (!languageModel) {
                 throw new Error('Couldn\'t find a matching language model. Please check your setup!');
             }
+
+            const systemMessageDescription = await this.getSystemMessageDescription();
             const messages = await this.getMessages(request.session);
             if (this.defaultLogging) {
-                this.recordingService.recordRequest({
-                    agentId: this.id,
-                    sessionId: request.session.id,
-                    timestamp: Date.now(),
-                    requestId: request.id,
-                    request: request.request.text,
-                    messages
-                });
+                this.recordingService.recordRequest(
+                    ChatHistoryEntry.fromRequest(
+                        this.id, request, {
+                        messages,
+                        systemMessage: systemMessageDescription?.text
+                    })
+                );
             }
 
-            const systemMessageDescription = await this.getSystemMessageDescription();
-            const tools: Map<string, ToolRequest> = new Map();
             if (systemMessageDescription) {
                 const systemMsg: ChatMessage = {
                     actor: 'system',
@@ -174,44 +181,35 @@ export abstract class AbstractChatAgent {
                 };
                 // insert system message at the beginning of the request messages
                 messages.unshift(systemMsg);
-                systemMessageDescription.functionDescriptions?.forEach((tool, id) => {
-                    tools.set(id, tool);
-                });
             }
-            this.getTools(request)?.forEach(tool => tools.set(tool.id, tool));
 
-            const cancellationToken = new CancellationTokenSource();
-            request.response.onDidChange(() => {
-                if (request.response.isCanceled) {
-                    cancellationToken.cancel();
-                }
-            });
+            const systemMessageToolRequests = systemMessageDescription?.functionDescriptions?.values();
+            const tools = [
+                ...this.chatToolRequestService.getChatToolRequests(request),
+                ...this.chatToolRequestService.toChatToolRequests(systemMessageToolRequests ? Array.from(systemMessageToolRequests) : [], request),
+                ...this.chatToolRequestService.toChatToolRequests(this.additionalToolRequests, request)
+            ];
 
             const languageModelResponse = await this.callLlm(
                 languageModel,
                 messages,
-                tools.size > 0 ? Array.from(tools.values()) : undefined,
-                cancellationToken.token
+                tools.length > 0 ? tools : undefined,
+                request.response.cancellationToken
             );
             await this.addContentsToResponse(languageModelResponse, request);
-            request.response.complete();
+            await this.onResponseComplete(request);
             if (this.defaultLogging) {
-                this.recordingService.recordResponse({
-                    agentId: this.id,
-                    sessionId: request.session.id,
-                    timestamp: Date.now(),
-                    requestId: request.response.requestId,
-                    response: request.response.response.asString()
-                });
+                this.recordingService.recordResponse(ChatHistoryEntry.fromResponse(this.id, request));
             }
         } catch (e) {
             this.handleError(request, e);
         }
     }
 
-    protected parseContents(text: string): ChatResponseContent[] {
+    protected parseContents(text: string, request: ChatRequestModelImpl): ChatResponseContent[] {
         return parseContents(
             text,
+            request,
             this.contentMatchers,
             this.defaultContentFactory?.create.bind(this.defaultContentFactory)
         );
@@ -264,15 +262,6 @@ export abstract class AbstractChatAgent {
         return requestMessages;
     }
 
-    /**
-     * @returns the list of tools used by this agent, or undefined if none is needed.
-     */
-    protected getTools(request: ChatRequestModel): ToolRequest[] | undefined {
-        return request.message.toolRequests.size > 0
-            ? [...request.message.toolRequests.values()]
-            : undefined;
-    }
-
     protected async callLlm(
         languageModel: LanguageModel,
         messages: ChatMessage[],
@@ -295,6 +284,16 @@ export abstract class AbstractChatAgent {
         return undefined;
     }
 
+    /**
+     * Invoked after the response by the LLM completed successfully.
+     *
+     * The default implementation sets the state of the response to `complete`.
+     * Subclasses may override this method to perform additional actions or keep the response open for processing further requests.
+     */
+    protected async onResponseComplete(request: ChatRequestModelImpl): Promise<void> {
+        return request.response.complete();
+    }
+
     protected abstract addContentsToResponse(languageModelResponse: LanguageModelResponse, request: ChatRequestModelImpl): Promise<void>;
 }
 
@@ -318,33 +317,12 @@ export abstract class AbstractStreamParsingChatAgent extends AbstractChatAgent {
 
     protected override async addContentsToResponse(languageModelResponse: LanguageModelResponse, request: ChatRequestModelImpl): Promise<void> {
         if (isLanguageModelTextResponse(languageModelResponse)) {
-            const contents = this.parseContents(languageModelResponse.text);
+            const contents = this.parseContents(languageModelResponse.text, request);
             request.response.response.addContents(contents);
-            request.response.complete();
-            if (this.defaultLogging) {
-                this.recordingService.recordResponse({
-                    agentId: this.id,
-                    sessionId: request.session.id,
-                    timestamp: Date.now(),
-                    requestId: request.response.requestId,
-                    response: request.response.response.asString()
-
-                });
-            }
             return;
         }
         if (isLanguageModelStreamResponse(languageModelResponse)) {
             await this.addStreamResponse(languageModelResponse, request);
-            request.response.complete();
-            if (this.defaultLogging) {
-                this.recordingService.recordResponse({
-                    agentId: this.id,
-                    sessionId: request.session.id,
-                    timestamp: Date.now(),
-                    requestId: request.response.requestId,
-                    response: request.response.response.asString()
-                });
-            }
             return;
         }
         this.logger.error(
@@ -359,7 +337,7 @@ export abstract class AbstractStreamParsingChatAgent extends AbstractChatAgent {
 
     protected async addStreamResponse(languageModelResponse: LanguageModelStreamResponse, request: ChatRequestModelImpl): Promise<void> {
         for await (const token of languageModelResponse.stream) {
-            const newContents = this.parse(token, request.response.response.content);
+            const newContents = this.parse(token, request);
             if (isArray(newContents)) {
                 request.response.response.addContents(newContents);
             } else {
@@ -375,7 +353,7 @@ export abstract class AbstractStreamParsingChatAgent extends AbstractChatAgent {
                 return;
             }
 
-            const result: ChatResponseContent[] = findFirstMatch(this.contentMatchers, text) ? this.parseContents(text) : [];
+            const result: ChatResponseContent[] = findFirstMatch(this.contentMatchers, text) ? this.parseContents(text, request) : [];
             if (result.length > 0) {
                 request.response.response.addContents(result);
             } else {
@@ -384,11 +362,11 @@ export abstract class AbstractStreamParsingChatAgent extends AbstractChatAgent {
         }
     }
 
-    protected parse(token: LanguageModelStreamResponsePart, previousContent: ChatResponseContent[]): ChatResponseContent | ChatResponseContent[] {
+    protected parse(token: LanguageModelStreamResponsePart, request: ChatRequestModelImpl): ChatResponseContent | ChatResponseContent[] {
         const content = token.content;
         // eslint-disable-next-line no-null/no-null
         if (content !== undefined && content !== null) {
-            return this.defaultContentFactory.create(content);
+            return this.defaultContentFactory.create(content, request);
         }
         const toolCalls = token.tool_calls;
         if (toolCalls !== undefined) {
@@ -396,7 +374,7 @@ export abstract class AbstractStreamParsingChatAgent extends AbstractChatAgent {
                 new ToolCallChatResponseContentImpl(toolCall.id, toolCall.function?.name, toolCall.function?.arguments, toolCall.finished, toolCall.result));
             return toolCallContents;
         }
-        return this.defaultContentFactory.create('');
+        return this.defaultContentFactory.create('', request);
     }
 
 }

package/src/common/chat-history-entry.ts

@@ -0,0 +1,47 @@
+// *****************************************************************************
+// Copyright (C) 2024 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 { CommunicationRequestEntryParam, CommunicationResponseEntryParam } from '@theia/ai-core/lib/common/communication-recording-service';
+import { ChatRequestModel } from './chat-model';
+
+export namespace ChatHistoryEntry {
+    export function fromRequest(
+        agentId: string,
+        request: ChatRequestModel,
+        args: Partial<CommunicationRequestEntryParam> = {}
+    ): CommunicationRequestEntryParam {
+        return {
+            agentId: agentId,
+            sessionId: request.session.id,
+            requestId: request.id,
+            request: request.request.text,
+            ...args,
+        };
+    }
+    export function fromResponse(
+        agentId: string,
+        request: ChatRequestModel,
+        args: Partial<CommunicationResponseEntryParam> = {}
+    ): CommunicationResponseEntryParam {
+        return {
+            agentId: agentId,
+            sessionId: request.session.id,
+            requestId: request.id,
+            response: request.response.response.asString(),
+            ...args,
+        };
+    }
+}

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

@@ -0,0 +1,44 @@
+// *****************************************************************************
+// Copyright (C) 2024 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 { ChatProgressMessage, ChatRequestModel, ChatResponse, ChatResponseContent, ChatResponseModel, QuestionResponseContent } from './chat-model';
+
+export function lastResponseContent(request: ChatRequestModel): ChatResponseContent | undefined {
+    return lastContentOfResponse(request.response?.response);
+}
+
+export function lastContentOfResponse(response: ChatResponse | undefined): ChatResponseContent | undefined {
+    const content = response?.content;
+    return content && content.length > 0 ? content[content.length - 1] : undefined;
+}
+
+export function lastProgressMessage(request: ChatRequestModel): ChatProgressMessage | undefined {
+    return lastProgressMessageOfResponse(request.response);
+}
+
+export function lastProgressMessageOfResponse(response: ChatResponseModel | undefined): ChatProgressMessage | undefined {
+    const progressMessages = response?.progressMessages;
+    return progressMessages && progressMessages.length > 0 ? progressMessages[progressMessages.length - 1] : undefined;
+}
+
+export function unansweredQuestions(request: ChatRequestModel): QuestionResponseContent[] {
+    const response = request.response;
+    return unansweredQuestionsOfResponse(response);
+}
+
+function unansweredQuestionsOfResponse(response: ChatResponseModel | undefined): QuestionResponseContent[] {
+    if (!response || !response.response) { return []; }
+    return response.response.content.filter((c): c is QuestionResponseContent => QuestionResponseContent.is(c) && c.selectedOption === undefined);
+}