@theia/ai-chat 1.54.0

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

@@ -0,0 +1,120 @@
+// *****************************************************************************
+// 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 * as sinon from 'sinon';
+import { ChatAgentServiceImpl } from './chat-agent-service';
+import { ChatRequestParserImpl } from './chat-request-parser';
+import { ChatAgentLocation } from './chat-agents';
+import { ChatRequest } from './chat-model';
+import { expect } from 'chai';
+import { DefaultAIVariableService, ToolInvocationRegistry, ToolInvocationRegistryImpl } from '@theia/ai-core';
+
+describe('ChatRequestParserImpl', () => {
+    const chatAgentService = sinon.createStubInstance(ChatAgentServiceImpl);
+    const variableService = sinon.createStubInstance(DefaultAIVariableService);
+    const toolInvocationRegistry: ToolInvocationRegistry = sinon.createStubInstance(ToolInvocationRegistryImpl);
+    const parser = new ChatRequestParserImpl(chatAgentService, variableService, toolInvocationRegistry);
+
+    it('parses simple text', () => {
+        const req: ChatRequest = {
+            text: 'What is the best pizza topping?'
+        };
+        const result = parser.parseChatRequest(req, ChatAgentLocation.Panel);
+        expect(result.parts).to.deep.contain({
+            text: 'What is the best pizza topping?',
+            range: { start: 0, endExclusive: 31 }
+        });
+    });
+
+    it('parses text with variable name', () => {
+        const req: ChatRequest = {
+            text: 'What is the #best pizza topping?'
+        };
+        const result = parser.parseChatRequest(req, ChatAgentLocation.Panel);
+        expect(result).to.deep.contain({
+            parts: [{
+                text: 'What is the ',
+                range: { start: 0, endExclusive: 12 }
+            }, {
+                variableName: 'best',
+                variableArg: undefined,
+                range: { start: 12, endExclusive: 17 }
+            }, {
+                text: ' pizza topping?',
+                range: { start: 17, endExclusive: 32 }
+            }]
+        });
+    });
+
+    it('parses text with variable name with argument', () => {
+        const req: ChatRequest = {
+            text: 'What is the #best:by-poll pizza topping?'
+        };
+        const result = parser.parseChatRequest(req, ChatAgentLocation.Panel);
+        expect(result).to.deep.contain({
+            parts: [{
+                text: 'What is the ',
+                range: { start: 0, endExclusive: 12 }
+            }, {
+                variableName: 'best',
+                variableArg: 'by-poll',
+                range: { start: 12, endExclusive: 25 }
+            }, {
+                text: ' pizza topping?',
+                range: { start: 25, endExclusive: 40 }
+            }]
+        });
+    });
+
+    it('parses text with variable name with numeric argument', () => {
+        const req: ChatRequest = {
+            text: '#size-class:2'
+        };
+        const result = parser.parseChatRequest(req, ChatAgentLocation.Panel);
+        expect(result.parts[0]).to.contain(
+            {
+                variableName: 'size-class',
+                variableArg: '2'
+            }
+        );
+    });
+
+    it('parses text with variable name with POSIX path argument', () => {
+        const req: ChatRequest = {
+            text: '#file:/path/to/file.ext'
+        };
+        const result = parser.parseChatRequest(req, ChatAgentLocation.Panel);
+        expect(result.parts[0]).to.contain(
+            {
+                variableName: 'file',
+                variableArg: '/path/to/file.ext'
+            }
+        );
+    });
+
+    it('parses text with variable name with Win32 path argument', () => {
+        const req: ChatRequest = {
+            text: '#file:c:\\path\\to\\file.ext'
+        };
+        const result = parser.parseChatRequest(req, ChatAgentLocation.Panel);
+        expect(result.parts[0]).to.contain(
+            {
+                variableName: 'file',
+                variableArg: 'c:\\path\\to\\file.ext'
+            }
+        );
+    });
+});

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

@@ -0,0 +1,220 @@
+// *****************************************************************************
+// 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
+// *****************************************************************************
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+// Partially copied from https://github.com/microsoft/vscode/blob/a2cab7255c0df424027be05d58e1b7b941f4ea60/src/vs/workbench/contrib/chat/common/chatRequestParser.ts
+
+import { inject, injectable } from '@theia/core/shared/inversify';
+import { ChatAgentService } from './chat-agent-service';
+import { ChatAgentLocation } from './chat-agents';
+import { ChatRequest } from './chat-model';
+import {
+    chatAgentLeader,
+    chatFunctionLeader,
+    ParsedChatRequestAgentPart,
+    ParsedChatRequestFunctionPart,
+    ParsedChatRequestTextPart,
+    ParsedChatRequestVariablePart,
+    chatVariableLeader,
+    OffsetRange,
+    ParsedChatRequest,
+    ParsedChatRequestPart,
+} from './parsed-chat-request';
+import { AIVariable, AIVariableService, ToolInvocationRegistry, ToolRequest } from '@theia/ai-core';
+
+const agentReg = /^@([\w_\-\.]+)(?=(\s|$|\b))/i; // An @-agent
+const functionReg = /^~([\w_\-\.]+)(?=(\s|$|\b))/i; // A ~ tool function
+const variableReg = /^#([\w_\-]+)(?::([\w_\-_\/\\.:]+))?(?=(\s|$|\b))/i; // A #-variable with an optional : arg (#file:workspace/path/name.ext)
+
+export const ChatRequestParser = Symbol('ChatRequestParser');
+export interface ChatRequestParser {
+    parseChatRequest(request: ChatRequest, location: ChatAgentLocation): ParsedChatRequest;
+}
+
+function offsetRange(start: number, endExclusive: number): OffsetRange {
+    if (start > endExclusive) {
+        throw new Error(`Invalid range: start=${start} endExclusive=${endExclusive}`);
+    }
+    return { start, endExclusive };
+}
+@injectable()
+export class ChatRequestParserImpl {
+    constructor(
+        @inject(ChatAgentService) private readonly agentService: ChatAgentService,
+        @inject(AIVariableService) private readonly variableService: AIVariableService,
+        @inject(ToolInvocationRegistry) private readonly toolInvocationRegistry: ToolInvocationRegistry
+    ) { }
+
+    parseChatRequest(request: ChatRequest, location: ChatAgentLocation): ParsedChatRequest {
+        const parts: ParsedChatRequestPart[] = [];
+        const variables = new Map<string, AIVariable>();
+        const toolRequests = new Map<string, ToolRequest>();
+        const message = request.text;
+        for (let i = 0; i < message.length; i++) {
+            const previousChar = message.charAt(i - 1);
+            const char = message.charAt(i);
+            let newPart: ParsedChatRequestPart | undefined;
+
+            if (previousChar.match(/\s/) || i === 0) {
+                if (char === chatFunctionLeader) {
+                    const functionPart = this.tryParseFunction(
+                        message.slice(i),
+                        i
+                    );
+                    newPart = functionPart;
+                    if (functionPart) {
+                        toolRequests.set(functionPart.toolRequest.id, functionPart.toolRequest);
+                    }
+                } else if (char === chatVariableLeader) {
+                    const variablePart = this.tryToParseVariable(
+                        message.slice(i),
+                        i,
+                        parts
+                    );
+                    newPart = variablePart;
+                    if (variablePart) {
+                        const variable = this.variableService.getVariable(variablePart.variableName);
+                        if (variable) {
+                            variables.set(variable.name, variable);
+                        }
+                    }
+                } else if (char === chatAgentLeader) {
+                    newPart = this.tryToParseAgent(
+                        message.slice(i),
+                        i,
+                        parts,
+                        location
+                    );
+                }
+            }
+
+            if (newPart) {
+                if (i !== 0) {
+                    // Insert a part for all the text we passed over, then insert the new parsed part
+                    const previousPart = parts.at(-1);
+                    const previousPartEnd =
+                        previousPart?.range.endExclusive ?? 0;
+                    parts.push(
+                        new ParsedChatRequestTextPart(
+                            offsetRange(previousPartEnd, i),
+                            message.slice(previousPartEnd, i)
+                        )
+                    );
+                }
+
+                parts.push(newPart);
+            }
+        }
+
+        const lastPart = parts.at(-1);
+        const lastPartEnd = lastPart?.range.endExclusive ?? 0;
+        if (lastPartEnd < message.length) {
+            parts.push(
+                new ParsedChatRequestTextPart(
+                    offsetRange(lastPartEnd, message.length),
+                    message.slice(lastPartEnd, message.length)
+                )
+            );
+        }
+
+        return { request, parts, toolRequests, variables };
+    }
+
+    private tryToParseAgent(
+        message: string,
+        offset: number,
+        parts: ReadonlyArray<ParsedChatRequestPart>,
+        location: ChatAgentLocation
+    ): ParsedChatRequestAgentPart | ParsedChatRequestVariablePart | undefined {
+        const nextAgentMatch = message.match(agentReg);
+        if (!nextAgentMatch) {
+            return;
+        }
+
+        const [full, name] = nextAgentMatch;
+        const agentRange = offsetRange(offset, offset + full.length);
+
+        let agents = this.agentService.getAgents().filter(a => a.name === name);
+        if (!agents.length) {
+            const fqAgent = this.agentService.getAgent(name);
+            if (fqAgent) {
+                agents = [fqAgent];
+            }
+        }
+
+        // If there is more than one agent with this name, and the user picked it from the suggest widget, then the selected agent should be in the
+        // context and we use that one. Otherwise just pick the first.
+        const agent = agents[0];
+        if (!agent || !agent.locations.includes(location)) {
+            return;
+        }
+
+        if (parts.some(p => p instanceof ParsedChatRequestAgentPart)) {
+            // Only one agent allowed
+            return;
+        }
+
+        // The agent must come first
+        if (
+            parts.some(
+                p =>
+                    (p instanceof ParsedChatRequestTextPart &&
+                        p.text.trim() !== '') ||
+                    !(p instanceof ParsedChatRequestAgentPart)
+            )
+        ) {
+            return;
+        }
+
+        return new ParsedChatRequestAgentPart(agentRange, agent.id, agent.name);
+    }
+
+    private tryToParseVariable(
+        message: string,
+        offset: number,
+        _parts: ReadonlyArray<ParsedChatRequestPart>
+    ): ParsedChatRequestVariablePart | undefined {
+        const nextVariableMatch = message.match(variableReg);
+        if (!nextVariableMatch) {
+            return;
+        }
+
+        const [full, name] = nextVariableMatch;
+        const variableArg = nextVariableMatch[2];
+        const varRange = offsetRange(offset, offset + full.length);
+
+        return new ParsedChatRequestVariablePart(varRange, name, variableArg);
+    }
+
+    private tryParseFunction(message: string, offset: number): ParsedChatRequestFunctionPart | undefined {
+        const nextFunctionMatch = message.match(functionReg);
+        if (!nextFunctionMatch) {
+            return;
+        }
+
+        const [full, id] = nextFunctionMatch;
+
+        const maybeToolRequest = this.toolInvocationRegistry.getFunction(id);
+        if (!maybeToolRequest) {
+            return;
+        }
+
+        const functionRange = offsetRange(offset, offset + full.length);
+        return new ParsedChatRequestFunctionPart(functionRange, maybeToolRequest);
+    }
+}

package/src/common/chat-service.ts

@@ -0,0 +1,236 @@
+// *****************************************************************************
+// 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
+// *****************************************************************************
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+// Partially copied from https://github.com/microsoft/vscode/blob/a2cab7255c0df424027be05d58e1b7b941f4ea60/src/vs/workbench/contrib/chat/common/chatService.ts
+
+import { inject, injectable, optional } from '@theia/core/shared/inversify';
+import {
+    ChatModel,
+    ChatModelImpl,
+    ChatRequest,
+    ChatRequestModel,
+    ChatResponseModel,
+    ErrorChatResponseModelImpl,
+} from './chat-model';
+import { ChatAgentService } from './chat-agent-service';
+import { Emitter, ILogger, generateUuid } from '@theia/core';
+import { ChatRequestParser } from './chat-request-parser';
+import { ChatAgent, ChatAgentLocation } from './chat-agents';
+import { ParsedChatRequestAgentPart, ParsedChatRequestVariablePart, ParsedChatRequest } from './parsed-chat-request';
+import { AIVariableService } from '@theia/ai-core';
+import { Event } from '@theia/core/shared/vscode-languageserver-protocol';
+
+export interface ChatRequestInvocation {
+    /**
+     * Promise which completes once the request preprocessing is complete.
+     */
+    requestCompleted: Promise<ChatRequestModel>;
+    /**
+     * Promise which completes once a response is expected to arrive.
+     */
+    responseCreated: Promise<ChatResponseModel>;
+    /**
+     * Promise which completes once the response is complete.
+     */
+    responseCompleted: Promise<ChatResponseModel>;
+}
+
+export interface ChatSession {
+    id: string;
+    title?: string;
+    model: ChatModel;
+    isActive: boolean;
+}
+
+export interface ActiveSessionChangedEvent {
+    sessionId: string | undefined;
+    focus?: boolean;
+}
+
+export interface SessionOptions {
+    focus?: boolean;
+}
+
+export const DefaultChatAgentId = Symbol('DefaultChatAgentId');
+export interface DefaultChatAgentId {
+    id: string;
+}
+
+export const ChatService = Symbol('ChatService');
+export interface ChatService {
+    onActiveSessionChanged: Event<ActiveSessionChangedEvent>
+
+    getSession(id: string): ChatSession | undefined;
+    getSessions(): ChatSession[];
+    createSession(location?: ChatAgentLocation, options?: SessionOptions): ChatSession;
+    deleteSession(sessionId: string): void;
+    setActiveSession(sessionId: string, options?: SessionOptions): void;
+
+    sendRequest(
+        sessionId: string,
+        request: ChatRequest
+    ): Promise<ChatRequestInvocation | undefined>;
+}
+
+interface ChatSessionInternal extends ChatSession {
+    model: ChatModelImpl;
+}
+
+@injectable()
+export class ChatServiceImpl implements ChatService {
+    protected readonly onActiveSessionChangedEmitter = new Emitter<ActiveSessionChangedEvent>();
+    onActiveSessionChanged = this.onActiveSessionChangedEmitter.event;
+
+    @inject(ChatAgentService)
+    protected chatAgentService: ChatAgentService;
+
+    @inject(DefaultChatAgentId) @optional()
+    protected defaultChatAgentId: DefaultChatAgentId | undefined;
+
+    @inject(ChatRequestParser)
+    protected chatRequestParser: ChatRequestParser;
+
+    @inject(AIVariableService)
+    protected variableService: AIVariableService;
+
+    @inject(ILogger)
+    protected logger: ILogger;
+
+    protected _sessions: ChatSessionInternal[] = [];
+
+    getSessions(): ChatSessionInternal[] {
+        return [...this._sessions];
+    }
+
+    getSession(id: string): ChatSessionInternal | undefined {
+        return this._sessions.find(session => session.id === id);
+    }
+
+    createSession(location = ChatAgentLocation.Panel, options?: SessionOptions): ChatSession {
+        const model = new ChatModelImpl(location);
+        const session: ChatSessionInternal = {
+            id: model.id,
+            model,
+            isActive: true
+        };
+        this._sessions.push(session);
+        this.setActiveSession(session.id, options);
+        return session;
+    }
+
+    deleteSession(sessionId: string): void {
+        // If the removed session is the active one, set the newest one as active
+        if (this.getSession(sessionId)?.isActive) {
+            this.setActiveSession(this._sessions[this._sessions.length - 1]?.id);
+        }
+        this._sessions = this._sessions.filter(item => item.id !== sessionId);
+    }
+
+    setActiveSession(sessionId: string | undefined, options?: SessionOptions): void {
+        this._sessions.forEach(session => {
+            session.isActive = session.id === sessionId;
+        });
+        this.onActiveSessionChangedEmitter.fire({ sessionId: sessionId, ...options });
+    }
+
+    async sendRequest(
+        sessionId: string,
+        request: ChatRequest
+    ): Promise<ChatRequestInvocation | undefined> {
+        const session = this.getSession(sessionId);
+        if (!session) {
+            return undefined;
+        }
+        session.title = request.text;
+
+        const parsedRequest = this.chatRequestParser.parseChatRequest(request, session.model.location);
+
+        const agent = this.getAgent(parsedRequest);
+        if (agent === undefined) {
+            const error = 'No ChatAgents available to handle request!';
+            this.logger.error(error);
+            const chatResponseModel = new ErrorChatResponseModelImpl(generateUuid(), new Error(error));
+            return {
+                requestCompleted: Promise.reject(error),
+                responseCreated: Promise.reject(error),
+                responseCompleted: Promise.resolve(chatResponseModel),
+            };
+        }
+        const requestModel = session.model.addRequest(parsedRequest, agent?.id);
+
+        for (const part of parsedRequest.parts) {
+            if (part instanceof ParsedChatRequestVariablePart) {
+                const resolvedVariable = await this.variableService.resolveVariable(
+                    { variable: part.variableName, arg: part.variableArg },
+                    { request, model: session }
+                );
+                if (resolvedVariable) {
+                    part.resolution = resolvedVariable;
+                } else {
+                    this.logger.warn(`Failed to resolve variable ${part.variableName} for ${session.model.location}`);
+                }
+            }
+        }
+
+        let resolveResponseCreated: (responseModel: ChatResponseModel) => void;
+        let resolveResponseCompleted: (responseModel: ChatResponseModel) => void;
+        const invocation: ChatRequestInvocation = {
+            requestCompleted: Promise.resolve(requestModel),
+            responseCreated: new Promise(resolve => {
+                resolveResponseCreated = resolve;
+            }),
+            responseCompleted: new Promise(resolve => {
+                resolveResponseCompleted = resolve;
+            }),
+        };
+
+        resolveResponseCreated!(requestModel.response);
+        requestModel.response.onDidChange(() => {
+            if (requestModel.response.isComplete) {
+                resolveResponseCompleted!(requestModel.response);
+            }
+            if (requestModel.response.isError) {
+                resolveResponseCompleted!(requestModel.response);
+            }
+        });
+
+        if (agent) {
+            agent.invoke(requestModel).catch(error => requestModel.response.error(error));
+        } else {
+            this.logger.error('No ChatAgents available to handle request!', requestModel);
+        }
+
+        return invocation;
+    }
+
+    protected getAgent(parsedRequest: ParsedChatRequest): ChatAgent | undefined {
+        const agentPart = this.getMentionedAgent(parsedRequest);
+        if (agentPart) {
+            return this.chatAgentService.getAgent(agentPart.agentId);
+        }
+        if (this.defaultChatAgentId) {
+            return this.chatAgentService.getAgent(this.defaultChatAgentId.id);
+        }
+        return this.chatAgentService.getAgents()[0] ?? undefined;
+    }
+
+    protected getMentionedAgent(parsedRequest: ParsedChatRequest): ParsedChatRequestAgentPart | undefined {
+        return parsedRequest.parts.find(p => p instanceof ParsedChatRequestAgentPart) as ParsedChatRequestAgentPart | undefined;
+    }
+}