@theia/ai-chat 1.56.0 → 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 { 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,
@@ -53,6 +52,7 @@ import {
 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.
@@ -123,10 +123,12 @@ 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)
@@ -171,7 +173,6 @@ export abstract class AbstractChatAgent {
                 );
             }
 
-            const tools: Map<string, ToolRequest> = new Map();
             if (systemMessageDescription) {
                 const systemMsg: ChatMessage = {
                     actor: 'system',
@@ -180,24 +181,20 @@ 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);
             await this.onResponseComplete(request);
@@ -265,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[],

package/src/common/chat-model.ts

@@ -19,11 +19,12 @@
  *--------------------------------------------------------------------------------------------*/
 // Partially copied from https://github.com/microsoft/vscode/blob/a2cab7255c0df424027be05d58e1b7b941f4ea60/src/vs/workbench/contrib/chat/common/chatModel.ts
 
-import { Command, Emitter, Event, generateUuid, URI } from '@theia/core';
+import { CancellationToken, CancellationTokenSource, Command, Disposable, Emitter, Event, generateUuid, URI } from '@theia/core';
 import { MarkdownString, MarkdownStringImpl } from '@theia/core/lib/common/markdown-rendering';
 import { Position } from '@theia/core/shared/vscode-languageserver-protocol';
 import { ChatAgentLocation } from './chat-agents';
-import { ParsedChatRequest } from './parsed-chat-request';
+import { ParsedChatRequest, ParsedChatRequestVariablePart } from './parsed-chat-request';
+import { ResolvedAIVariable } from '@theia/ai-core';
 
 /**********************
  * INTERFACES AND TYPE GUARDS
@@ -32,7 +33,11 @@ import { ParsedChatRequest } from './parsed-chat-request';
 export type ChatChangeEvent =
     | ChatAddRequestEvent
     | ChatAddResponseEvent
-    | ChatRemoveRequestEvent;
+    | ChatRemoveRequestEvent
+    | ChatSetChangeSetEvent
+    | ChatSetChangeDeleteEvent
+    | ChatUpdateChangeSetEvent
+    | ChatRemoveChangeSetEvent;
 
 export interface ChatAddRequestEvent {
     kind: 'addRequest';
@@ -44,6 +49,31 @@ export interface ChatAddResponseEvent {
     response: ChatResponseModel;
 }
 
+export interface ChatSetChangeSetEvent {
+    kind: 'setChangeSet';
+    changeSet: ChangeSet;
+}
+
+export interface ChatSetChangeDeleteEvent {
+    kind: 'deleteChangeSet';
+}
+
+export interface ChatUpdateChangeSetEvent {
+    kind: 'updateChangeSet';
+    changeSet: ChangeSet;
+}
+
+export interface ChatRemoveChangeSetEvent {
+    kind: 'removeChangeSet';
+    changeSet: ChangeSet;
+}
+
+export namespace ChatChangeEvent {
+    export function isChangeSetEvent(event: ChatChangeEvent): event is ChatSetChangeSetEvent | ChatUpdateChangeSetEvent | ChatRemoveChangeSetEvent {
+        return event.kind === 'setChangeSet' || event.kind === 'deleteChangeSet' || event.kind === 'removeChangeSet' || event.kind === 'updateChangeSet';
+    }
+}
+
 export type ChatRequestRemovalReason = 'removal' | 'resend' | 'adoption';
 
 export interface ChatRemoveRequestEvent {
@@ -57,10 +87,33 @@ export interface ChatModel {
     readonly onDidChange: Event<ChatChangeEvent>;
     readonly id: string;
     readonly location: ChatAgentLocation;
+    readonly changeSet?: ChangeSet;
     getRequests(): ChatRequestModel[];
     isEmpty(): boolean;
 }
 
+export interface ChangeSet {
+    readonly title: string;
+    getElements(): ChangeSetElement[];
+}
+
+export interface ChangeSetElement {
+    readonly uri: URI;
+
+    readonly name?: string;
+    readonly icon?: string;
+    readonly additionalInfo?: string;
+
+    readonly state?: 'pending' | 'applied' | 'discarded';
+    readonly type?: 'add' | 'modify' | 'delete';
+    readonly data?: { [key: string]: unknown };
+
+    open?(): Promise<void>;
+    openChange?(): Promise<void>;
+    accept?(): Promise<void>;
+    discard?(): Promise<void>;
+}
+
 export interface ChatRequest {
     readonly text: string;
     readonly displayText?: string;
@@ -76,6 +129,32 @@ export interface ChatRequestModel {
     readonly data?: { [key: string]: unknown };
 }
 
+export namespace ChatRequestModel {
+    export function is(request: unknown): request is ChatRequestModel {
+        return !!(
+            request &&
+            typeof request === 'object' &&
+            'id' in request &&
+            typeof (request as { id: unknown }).id === 'string' &&
+            'session' in request &&
+            'request' in request &&
+            'response' in request &&
+            'message' in request
+        );
+    }
+    export function isInProgress(request: ChatRequestModel | undefined): boolean {
+        if (!request) {
+            return false;
+        }
+        const response = request.response;
+        return !(
+            response.isComplete ||
+            response.isCanceled ||
+            response.isError
+        );
+    }
+}
+
 export interface ChatProgressMessage {
     kind: 'progressMessage';
     id: string;
@@ -321,18 +400,59 @@ export interface ChatResponse {
     asString(): string;
 }
 
+/**
+ * The ChatResponseModel wraps the actual ChatResponse with additional information like the current state, progress messages, a unique id etc.
+ */
 export interface ChatResponseModel {
+    /**
+     * Use this to be notified for any change in the response model
+     */
     readonly onDidChange: Event<void>;
+    /**
+     * The unique identifier of the response model
+     */
     readonly id: string;
+    /**
+     * The unique identifier of the request model this response is associated with
+     */
     readonly requestId: string;
+    /**
+     * In case there are progress messages, then they will be stored here
+     */
     readonly progressMessages: ChatProgressMessage[];
+    /**
+     * The actual response content
+     */
     readonly response: ChatResponse;
+    /**
+     * Indicates whether this response is complete. No further changes are expected if 'true'.
+     */
     readonly isComplete: boolean;
+    /**
+     * Indicates whether this response is canceled. No further changes are expected if 'true'.
+     */
     readonly isCanceled: boolean;
+    /**
+     * Some agents might need to wait for user input to continue. This flag indicates that.
+     */
     readonly isWaitingForInput: boolean;
+    /**
+     * Indicates whether an error occurred when processing the response. No further changes are expected if 'true'.
+     */
     readonly isError: boolean;
+    /**
+     * The agent who produced the response content, if there is one.
+     */
     readonly agentId?: string
+    /**
+     * An optional error object that caused the response to be in an error state.
+     */
     readonly errorObject?: Error;
+    /**
+     * Some functionality might want to store some data associated with the response.
+     * This can be used to store and retrieve such data.
+     */
+    readonly data: { [key: string]: unknown };
 }
 
 /**********************
@@ -345,6 +465,8 @@ export class ChatModelImpl implements ChatModel {
 
     protected _requests: ChatRequestModelImpl[];
     protected _id: string;
+    protected _changeSetListener?: Disposable;
+    protected _changeSet?: ChangeSetImpl;
 
     constructor(public readonly location = ChatAgentLocation.Panel) {
         // TODO accept serialized data as a parameter to restore a previously saved ChatModel
@@ -356,12 +478,52 @@ export class ChatModelImpl implements ChatModel {
         return this._requests;
     }
 
+    getRequest(id: string): ChatRequestModelImpl | undefined {
+        return this._requests.find(request => request.id === id);
+    }
+
     get id(): string {
         return this._id;
     }
 
-    addRequest(parsedChatRequest: ParsedChatRequest, agentId?: string): ChatRequestModelImpl {
-        const requestModel = new ChatRequestModelImpl(this, parsedChatRequest, agentId);
+    get changeSet(): ChangeSetImpl | undefined {
+        return this._changeSet;
+    }
+
+    setChangeSet(changeSet: ChangeSetImpl | undefined): void {
+        this._changeSet = changeSet;
+        if (this._changeSet === undefined) {
+            this._changeSetListener?.dispose();
+            this._onDidChangeEmitter.fire({
+                kind: 'deleteChangeSet',
+            });
+            return;
+        }
+        this._onDidChangeEmitter.fire({
+            kind: 'setChangeSet',
+            changeSet: this._changeSet,
+        });
+        this._changeSetListener = this._changeSet.onDidChange(() => {
+            this._onDidChangeEmitter.fire({
+                kind: 'updateChangeSet',
+                changeSet: this._changeSet!,
+            });
+        });
+    }
+
+    removeChangeSet(): void {
+        if (this._changeSet) {
+            const oldChangeSet = this._changeSet;
+            this._changeSet = undefined;
+            this._onDidChangeEmitter.fire({
+                kind: 'removeChangeSet',
+                changeSet: oldChangeSet,
+            });
+        }
+    }
+
+    addRequest(parsedChatRequest: ParsedChatRequest, agentId?: string, context: ResolvedAIVariable[] = []): ChatRequestModelImpl {
+        const requestModel = new ChatRequestModelImpl(this, parsedChatRequest, agentId, context);
         this._requests.push(requestModel);
         this._onDidChangeEmitter.fire({
             kind: 'addRequest',
@@ -375,21 +537,72 @@ export class ChatModelImpl implements ChatModel {
     }
 }
 
+export class ChangeSetImpl implements ChangeSet {
+    protected readonly _onDidChangeEmitter = new Emitter<void>();
+    onDidChange: Event<void> = this._onDidChangeEmitter.event;
+
+    protected _elements: ChangeSetElement[] = [];
+
+    constructor(public readonly title: string, elements: ChangeSetElement[] = []) {
+        this.addElements(elements);
+    }
+
+    getElements(): ChangeSetElement[] {
+        return this._elements;
+    }
+
+    addElement(element: ChangeSetElement): void {
+        this.addElements([element]);
+    }
+
+    addElements(elements: ChangeSetElement[]): void {
+        this._elements.push(...elements);
+        this.notifyChange();
+    }
+
+    replaceElement(element: ChangeSetElement): boolean {
+        const index = this._elements.findIndex(e => e.uri.toString() === element.uri.toString());
+        if (index < 0) {
+            return false;
+        }
+        this._elements[index] = element;
+        this.notifyChange();
+        return true;
+    }
+
+    addOrReplaceElement(element: ChangeSetElement): void {
+        if (!this.replaceElement(element)) {
+            this.addElement(element);
+        }
+    }
+
+    removeElement(index: number): void {
+        this._elements.splice(index, 1);
+        this.notifyChange();
+    }
+
+    notifyChange(): void {
+        this._onDidChangeEmitter.fire();
+    }
+}
+
 export class ChatRequestModelImpl implements ChatRequestModel {
     protected readonly _id: string;
-    protected _session: ChatModel;
+    protected _session: ChatModelImpl;
     protected _request: ChatRequest;
     protected _response: ChatResponseModelImpl;
+    protected _context: ResolvedAIVariable[];
     protected _agentId?: string;
     protected _data: { [key: string]: unknown };
 
-    constructor(session: ChatModel, public readonly message: ParsedChatRequest, agentId?: string,
-        data: { [key: string]: unknown } = {}) {
+    constructor(session: ChatModelImpl, public readonly message: ParsedChatRequest, agentId?: string,
+        context: ResolvedAIVariable[] = [], data: { [key: string]: unknown } = {}) {
         // TODO accept serialized data as a parameter to restore a previously saved ChatRequestModel
         this._request = message.request;
         this._id = generateUuid();
         this._session = session;
         this._response = new ChatResponseModelImpl(this._id, agentId);
+        this._context = context.concat(message.parts.filter(part => part.kind === 'var').map(part => (part as ParsedChatRequestVariablePart).resolution));
         this._agentId = agentId;
         this._data = data;
     }
@@ -410,7 +623,7 @@ export class ChatRequestModelImpl implements ChatRequestModel {
         return this._id;
     }
 
-    get session(): ChatModel {
+    get session(): ChatModelImpl {
         return this._session;
     }
 
@@ -425,6 +638,10 @@ export class ChatRequestModelImpl implements ChatRequestModel {
     get agentId(): string | undefined {
         return this._agentId;
     }
+
+    cancel(): void {
+        this.response.cancel();
+    }
 }
 
 export class ErrorChatResponseContentImpl implements ErrorChatResponseContent {
@@ -750,16 +967,18 @@ class ChatResponseModelImpl implements ChatResponseModel {
     protected readonly _onDidChangeEmitter = new Emitter<void>();
     onDidChange: Event<void> = this._onDidChangeEmitter.event;
 
+    data = {};
+
     protected _id: string;
     protected _requestId: string;
     protected _progressMessages: ChatProgressMessage[];
     protected _response: ChatResponseImpl;
     protected _isComplete: boolean;
-    protected _isCanceled: boolean;
     protected _isWaitingForInput: boolean;
     protected _agentId?: string;
     protected _isError: boolean;
     protected _errorObject: Error | undefined;
+    protected _cancellationToken: CancellationTokenSource;
 
     constructor(requestId: string, agentId?: string) {
         // TODO accept serialized data as a parameter to restore a previously saved ChatResponseModel
@@ -770,9 +989,9 @@ class ChatResponseModelImpl implements ChatResponseModel {
         response.onDidChange(() => this._onDidChangeEmitter.fire());
         this._response = response;
         this._isComplete = false;
-        this._isCanceled = false;
         this._isWaitingForInput = false;
         this._agentId = agentId;
+        this._cancellationToken = new CancellationTokenSource();
     }
 
     get id(): string {
@@ -827,7 +1046,7 @@ class ChatResponseModelImpl implements ChatResponseModel {
     }
 
     get isCanceled(): boolean {
-        return this._isCanceled;
+        return this._cancellationToken.token.isCancellationRequested;
     }
 
     get isWaitingForInput(): boolean {
@@ -849,12 +1068,16 @@ class ChatResponseModelImpl implements ChatResponseModel {
     }
 
     cancel(): void {
+        this._cancellationToken.cancel();
         this._isComplete = true;
-        this._isCanceled = true;
         this._isWaitingForInput = false;
         this._onDidChangeEmitter.fire();
     }
 
+    get cancellationToken(): CancellationToken {
+        return this._cancellationToken.token;
+    }
+
     waitForInput(): void {
         this._isWaitingForInput = true;
         this._onDidChangeEmitter.fire();
@@ -867,7 +1090,6 @@ class ChatResponseModelImpl implements ChatResponseModel {
 
     error(error: Error): void {
         this._isComplete = true;
-        this._isCanceled = false;
         this._isWaitingForInput = false;
         this._isError = true;
         this._errorObject = error;

package/src/common/chat-service.ts

@@ -86,6 +86,11 @@ export interface ChatService {
         sessionId: string,
         request: ChatRequest
     ): Promise<ChatRequestInvocation | undefined>;
+
+    deleteChangeSet(sessionId: string): void;
+    deleteChangeSetElement(sessionId: string, index: number): void;
+
+    cancelRequest(sessionId: string, requestId: string): Promise<void>;
 }
 
 interface ChatSessionInternal extends ChatSession {
@@ -219,6 +224,10 @@ export class ChatServiceImpl implements ChatService {
         return invocation;
     }
 
+    async cancelRequest(sessionId: string, requestId: string): Promise<void> {
+        return this.getSession(sessionId)?.model.getRequest(requestId)?.response.cancel();
+    }
+
     protected getAgent(parsedRequest: ParsedChatRequest): ChatAgent | undefined {
         const agentPart = this.getMentionedAgent(parsedRequest);
         if (agentPart) {
@@ -233,4 +242,12 @@ export class ChatServiceImpl implements ChatService {
     protected getMentionedAgent(parsedRequest: ParsedChatRequest): ParsedChatRequestAgentPart | undefined {
         return parsedRequest.parts.find(p => p instanceof ParsedChatRequestAgentPart) as ParsedChatRequestAgentPart | undefined;
     }
+
+    deleteChangeSet(sessionId: string): void {
+        this.getSession(sessionId)?.model.setChangeSet(undefined);
+    }
+
+    deleteChangeSetElement(sessionId: string, index: number): void {
+        this.getSession(sessionId)?.model.changeSet?.removeElement(index);
+    }
 }