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

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,10 +129,37 @@ 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;
     status: 'inProgress' | 'completed' | 'failed';
+    show: 'untilFirstContent' | 'whileIncomplete' | 'forever';
     content: string;
 }
 
@@ -279,22 +359,100 @@ export namespace ErrorChatResponseContent {
     }
 }
 
+export type QuestionResponseHandler = (
+    selectedOption: { text: string, value?: string },
+) => void;
+
+export interface QuestionResponseContent extends ChatResponseContent {
+    kind: 'question';
+    question: string;
+    options: { text: string, value?: string }[];
+    selectedOption?: { text: string, value?: string };
+    handler: QuestionResponseHandler;
+    request: ChatRequestModelImpl;
+}
+
+export namespace QuestionResponseContent {
+    export function is(obj: unknown): obj is QuestionResponseContent {
+        return (
+            ChatResponseContent.is(obj) &&
+            obj.kind === 'question' &&
+            'question' in obj &&
+            typeof (obj as { question: unknown }).question === 'string' &&
+            'options' in obj &&
+            Array.isArray((obj as { options: unknown }).options) &&
+            (obj as { options: unknown[] }).options.every(option =>
+                typeof option === 'object' &&
+                option && 'text' in option &&
+                typeof (option as { text: unknown }).text === 'string' &&
+                ('value' in option ? typeof (option as { value: unknown }).value === 'string' || typeof (option as { value: unknown }).value === 'undefined' : true)
+            ) &&
+            'handler' in obj &&
+            typeof (obj as { handler: unknown }).handler === 'function' &&
+            'request' in obj &&
+            obj.request instanceof ChatRequestModelImpl
+        );
+    }
+}
+
 export interface ChatResponse {
     readonly content: ChatResponseContent[];
     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 };
 }
 
 /**********************
@@ -307,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
@@ -318,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',
@@ -337,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;
     }
@@ -372,7 +623,7 @@ export class ChatRequestModelImpl implements ChatRequestModel {
         return this._id;
     }
 
-    get session(): ChatModel {
+    get session(): ChatModelImpl {
         return this._session;
     }
 
@@ -387,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 {
@@ -602,6 +857,31 @@ export class HorizontalLayoutChatResponseContentImpl implements HorizontalLayout
     }
 }
 
+/**
+ * Default implementation for the QuestionResponseContent.
+ */
+export class QuestionResponseContentImpl implements QuestionResponseContent {
+    readonly kind = 'question';
+    protected _selectedOption: { text: string; value?: string } | undefined;
+    constructor(public question: string, public options: { text: string, value?: string }[],
+        public request: ChatRequestModelImpl, public handler: QuestionResponseHandler) {
+    }
+    set selectedOption(option: { text: string; value?: string; } | undefined) {
+        this._selectedOption = option;
+        this.request.response.response.responseContentChanged();
+    }
+    get selectedOption(): { text: string; value?: string; } | undefined {
+        return this._selectedOption;
+    }
+    asString?(): string | undefined {
+        return `Question: ${this.question}
+${this.selectedOption ? `Answer: ${this.selectedOption?.text}` : 'No answer'}`;
+    }
+    merge?(): boolean {
+        return false;
+    }
+}
+
 class ChatResponseImpl implements ChatResponse {
     protected readonly _onDidChangeEmitter = new Emitter<void>();
     onDidChange: Event<void> = this._onDidChangeEmitter.event;
@@ -654,6 +934,11 @@ class ChatResponseImpl implements ChatResponse {
         this._updateResponseRepresentation();
     }
 
+    responseContentChanged(): void {
+        this._updateResponseRepresentation();
+        this._onDidChangeEmitter.fire();
+    }
+
     protected _updateResponseRepresentation(): void {
         this._responseRepresentation = this._content
             .map(responseContent => {
@@ -682,15 +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
@@ -701,8 +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 {
@@ -728,6 +1017,7 @@ class ChatResponseModelImpl implements ChatResponseModel {
             kind: 'progressMessage',
             id,
             status: message.status ?? 'inProgress',
+            show: message.show ?? 'untilFirstContent',
             ...message,
         };
         this._progressMessages.push(newMessage);
@@ -756,7 +1046,11 @@ class ChatResponseModelImpl implements ChatResponseModel {
     }
 
     get isCanceled(): boolean {
-        return this._isCanceled;
+        return this._cancellationToken.token.isCancellationRequested;
+    }
+
+    get isWaitingForInput(): boolean {
+        return this._isWaitingForInput;
     }
 
     get agentId(): string | undefined {
@@ -769,17 +1063,34 @@ class ChatResponseModelImpl implements ChatResponseModel {
 
     complete(): void {
         this._isComplete = true;
+        this._isWaitingForInput = false;
         this._onDidChangeEmitter.fire();
     }
 
     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();
     }
+
+    stopWaitingForInput(): void {
+        this._isWaitingForInput = false;
+        this._onDidChangeEmitter.fire();
+    }
+
     error(error: Error): void {
         this._isComplete = true;
-        this._isCanceled = false;
+        this._isWaitingForInput = false;
         this._isError = true;
         this._errorObject = error;
         this._onDidChangeEmitter.fire();

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

package/src/common/chat-tool-request-service.ts

@@ -0,0 +1,59 @@
+// *****************************************************************************
+// 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 { ToolRequest } from '@theia/ai-core';
+import { injectable } from '@theia/core/shared/inversify';
+import { ChatRequestModelImpl } from './chat-model';
+
+export interface ChatToolRequest extends ToolRequest {
+    handler: (
+        arg_string: string,
+        context: ChatRequestModelImpl,
+    ) => Promise<unknown>;
+}
+
+/**
+ * Wraps tool requests in a chat context.
+ *
+ * This service extracts tool requests from a given chat request model and wraps their
+ * handler functions to provide additional context, such as the chat request model.
+ */
+@injectable()
+export class ChatToolRequestService {
+
+    getChatToolRequests(request: ChatRequestModelImpl): ChatToolRequest[] {
+        const toolRequests = request.message.toolRequests.size > 0 ? [...request.message.toolRequests.values()] : undefined;
+        if (!toolRequests) {
+            return [];
+        }
+        return this.toChatToolRequests(toolRequests, request);
+    }
+
+    toChatToolRequests(toolRequests: ToolRequest[] | undefined, request: ChatRequestModelImpl): ChatToolRequest[] {
+        if (!toolRequests) {
+            return [];
+        }
+        return toolRequests.map(toolRequest => this.toChatToolRequest(toolRequest, request));
+    }
+
+    protected toChatToolRequest(toolRequest: ToolRequest, request: ChatRequestModelImpl): ChatToolRequest {
+        return {
+            ...toolRequest,
+            handler: async (arg_string: string) => toolRequest.handler(arg_string, request)
+        };
+    }
+
+}

package/src/common/command-chat-agents.ts

@@ -36,7 +36,9 @@ import {
 
 export const commandTemplate: PromptTemplate = {
     id: 'command-system',
-    template: `# System Prompt
+    template: `{{!-- Made improvements or adaptations to this prompt template? We’d love for you to share it with the community! Contribute back here:
+https://github.com/eclipse-theia/theia/discussions/new?category=prompt-template-contribution --}}
+# System Prompt
 
 You are a service that helps users find commands to execute in an IDE.
 You reply with stringified JSON Objects that tell the user which command to execute and its arguments, if any. 
@@ -313,7 +315,7 @@ export class CommandChatAgent extends AbstractTextToModelParsingChatAgent<Parsed
             const theiaCommand = this.commandRegistry.getCommand(parsedCommand.commandId);
             if (theiaCommand === undefined) {
                 console.error(`No Theia Command with id ${parsedCommand.commandId}`);
-                request.response.cancel();
+                request.cancel();
             }
             const args = parsedCommand.arguments !== undefined &&
                 parsedCommand.arguments.length > 0

package/src/common/index.ts

@@ -16,6 +16,7 @@
 export * from './chat-agents';
 export * from './chat-agent-service';
 export * from './chat-model';
+export * from './chat-model-util';
 export * from './chat-request-parser';
 export * from './chat-service';
 export * from './command-chat-agents';