@theia/ai-chat 1.54.0

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

@@ -0,0 +1,352 @@
+// *****************************************************************************
+// 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 { inject, injectable } from '@theia/core/shared/inversify';
+import { AbstractTextToModelParsingChatAgent, ChatAgent, SystemMessageDescription } from './chat-agents';
+import {
+    PromptTemplate,
+    AgentSpecificVariables
+} from '@theia/ai-core';
+import {
+    ChatRequestModelImpl,
+    ChatResponseContent,
+    CommandChatResponseContentImpl,
+    CustomCallback,
+    HorizontalLayoutChatResponseContentImpl,
+    MarkdownChatResponseContentImpl,
+} from './chat-model';
+import {
+    CommandRegistry,
+    MessageService,
+    generateUuid,
+} from '@theia/core';
+
+export const commandTemplate: PromptTemplate = {
+    id: 'command-system',
+    template: `# 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. 
+
+# Examples
+
+The examples start with a short explanation of the return object. 
+The response can be found within the markdown \`\`\`json and \`\`\` markers.
+Please include these markers in the reply.
+
+Never under any circumstances may you reply with just the command-id!
+
+## Example 1
+
+This reply is to tell the user to execute the \`theia-ai-prompt-template:show-prompts-command\` command that is available in the Theia command registry.
+
+\`\`\`json
+{
+    "type": "theia-command",
+    "commandId": "theia-ai-prompt-template:show-prompts-command"
+}
+\`\`\`
+
+## Example 2
+
+This reply is to tell the user to execute the \`theia-ai-prompt-template:show-prompts-command\` command that is available in the theia command registry, 
+when the user want to pass arguments to the command.
+
+\`\`\`json
+{
+    "type": "theia-command",
+    "commandId": "theia-ai-prompt-template:show-prompts-command",
+    "arguments": ["foo"]
+}
+\`\`\`
+
+## Example 3
+
+This reply is for custom commands that are not registered in the Theia command registry. 
+These commands always have the command id \`ai-chat.command-chat-response.generic\`.
+The arguments are an array and may differ, depending on the user's instructions. 
+
+\`\`\`json
+{
+    "type": "custom-handler",
+    "commandId": "ai-chat.command-chat-response.generic",
+    "arguments": ["foo", "bar"]
+}
+\`\`\`
+
+## Example 4
+
+This reply of type no-command is for cases where you can't find a proper command. 
+You may use the message to explain the situation to the user.
+
+\`\`\`json
+{
+    "type": "no-command",
+    "message": "a message explaining what is wrong"
+}
+\`\`\`
+
+# Rules
+
+## Theia Commands
+
+If a user asks for a Theia command, or the context implies it is about a command in Theia, return a response with \`"type": "theia-command"\`.
+You need to exchange the "commandId". 
+The available command ids in Theia are in the list below. The list of commands is formatted like this:
+
+command-id1: Label1
+command-id2: Label2
+command-id3: 
+command-id4: Label4
+
+The Labels may be empty, but there is always a command-id.
+
+Suggest a command that probably fits the user's message based on the label and the command ids you know. 
+If you have multiple commands that fit, return the one that fits best. We only want a single command in the reply.
+If the user says that the last command was not right, try to return the next best fit based on the conversation history with the user.
+
+If there are no more command ids that seem to fit, return a response of \`"type": "no-command"\` explaining the situation.
+
+Here are the known Theia commands:
+
+Begin List:
+{{command-ids}}
+End List
+
+You may only use commands from this list when responding with \`"type": "theia-command"\`.
+Do not come up with command ids that are not in this list.
+If you need to do this, use the \`"type": "no-command"\`. instead
+
+## Custom Handlers
+
+If the user asks for a command that is not a Theia command, return a response with \`"type": "custom-handler"\`.
+
+## Other Cases
+
+In all other cases, return a reply of \`"type": "no-command"\`.
+
+# Examples of Invalid Responses
+
+## Invalid Response Example 1
+
+This example is invalid because it returns text and two commands. 
+Only one command should be replied, and it must be parseable JSON.
+
+### The Example
+
+Yes, there are a few more theme-related commands. Here is another one:
+
+\`\`\`json
+{
+    "type": "theia-command",
+    "commandId": "workbench.action.selectIconTheme"
+}
+\`\`\`
+
+And another one:
+
+\`\`\`json
+{
+    "type": "theia-command",
+    "commandId": "core.close.right.tabs"
+}
+\`\`\`
+
+## Invalid Response Example 2
+
+The following example is invalid because it only returns the command id and is not parseable JSON:
+
+### The Example
+
+workbench.action.selectIconTheme
+
+## Invalid Response Example 3
+
+The following example is invalid because it returns a message with the command id. We need JSON objects based on the above rules.
+Do not respond like this in any case! We need a command of \`"type": "theia-command"\`.
+
+The expected response would be:
+\`\`\`json
+{
+    "type": "theia-command",
+    "commandId": "core.close.right.tabs"
+}
+\`\`\`
+
+### The Example
+
+I found this command that might help you: core.close.right.tabs
+
+## Invalid Response Example 4
+
+The following example is invalid because it has an explanation string before the JSON. 
+We only want the JSON!
+
+### The Example
+
+You can toggle high contrast mode with this command:
+
+\`\`\`json
+{
+    "type": "theia-command",
+    "commandId": "editor.action.toggleHighContrast"
+}
+\`\`\`
+
+## Invalid Response Example 5
+
+The following example is invalid because it explains that no command was found. 
+We want a response of \`"type": "no-command"\` and have the message there.
+
+### The Example
+
+There is no specific command available to "open the windows" in the provided Theia command list.
+
+## Invalid Response Example 6
+
+In this example we were using the following theia id command list:
+
+Begin List:
+container--theia-open-editors-widget: Hello
+foo:toggle-visibility-explorer-view-container--files: Label 1
+foo:toggle-visibility-explorer-view-container--plugin-view: Label 2
+End List
+
+The problem is that workbench.action.toggleHighContrast is not in this list. 
+theia-command types may only use commandIds from this list. 
+This should have been of \`"type": "no-command"\`.
+
+### The Example
+
+\`\`\`json
+{
+    "type": "theia-command",
+    "commandId": "workbench.action.toggleHighContrast"
+}
+\`\`\`
+
+`};
+
+interface ParsedCommand {
+    type: 'theia-command' | 'custom-handler' | 'no-command'
+    commandId: string;
+    arguments?: string[];
+    message?: string;
+}
+
+@injectable()
+export class CommandChatAgent extends AbstractTextToModelParsingChatAgent<ParsedCommand> implements ChatAgent {
+    @inject(CommandRegistry)
+    protected commandRegistry: CommandRegistry;
+    @inject(MessageService)
+    protected messageService: MessageService;
+    readonly name: string;
+    readonly description: string;
+    readonly variables: string[];
+    readonly promptTemplates: PromptTemplate[];
+    readonly functions: string[];
+    readonly agentSpecificVariables: AgentSpecificVariables[];
+
+    constructor(
+    ) {
+        super('Command', [{
+            purpose: 'command',
+            identifier: 'openai/gpt-4o',
+        }], 'command');
+        this.name = 'Command';
+        this.description = 'This agent is aware of all commands that the user can execute within the Theia IDE, the tool that the user is currently working with. \
+        Based on the user request, it can find the right command and then let the user execute it.';
+        this.variables = [];
+        this.promptTemplates = [commandTemplate];
+        this.functions = [];
+        this.agentSpecificVariables = [{
+            name: 'command-ids',
+            description: 'The list of available commands in Theia.',
+            usedInPrompt: true
+        }];
+    }
+
+    protected async getSystemMessageDescription(): Promise<SystemMessageDescription | undefined> {
+        const knownCommands: string[] = [];
+        for (const command of this.commandRegistry.getAllCommands()) {
+            knownCommands.push(`${command.id}: ${command.label}`);
+        }
+        const systemPrompt = await this.promptService.getPrompt(commandTemplate.id, {
+            'command-ids': knownCommands.join('\n')
+        });
+        if (systemPrompt === undefined) {
+            throw new Error('Couldn\'t get system prompt ');
+        }
+        return SystemMessageDescription.fromResolvedPromptTemplate(systemPrompt);
+    }
+
+    /**
+     * @param text the text received from the language model
+     * @returns the parsed command if the text contained a valid command.
+     * If there was no json in the text, return a no-command response.
+     */
+    protected async parseTextResponse(text: string): Promise<ParsedCommand> {
+        const jsonMatch = text.match(/(\{[\s\S]*\})/);
+        const jsonString = jsonMatch ? jsonMatch[1] : `{
+    "type": "no-command",
+    "message": "Please try again."
+}`;
+        const parsedCommand = JSON.parse(jsonString) as ParsedCommand;
+        return parsedCommand;
+    }
+
+    protected createResponseContent(parsedCommand: ParsedCommand, request: ChatRequestModelImpl): ChatResponseContent {
+        if (parsedCommand.type === 'theia-command') {
+            const theiaCommand = this.commandRegistry.getCommand(parsedCommand.commandId);
+            if (theiaCommand === undefined) {
+                console.error(`No Theia Command with id ${parsedCommand.commandId}`);
+                request.response.cancel();
+            }
+            const args = parsedCommand.arguments !== undefined &&
+                parsedCommand.arguments.length > 0
+                ? parsedCommand.arguments
+                : undefined;
+
+            return new HorizontalLayoutChatResponseContentImpl([
+                new MarkdownChatResponseContentImpl(
+                    'I found this command that might help you:'
+                ),
+                new CommandChatResponseContentImpl(theiaCommand, undefined, args),
+            ]);
+        } else if (parsedCommand.type === 'custom-handler') {
+            const id = `ai-command-${generateUuid()}`;
+            const commandArgs = parsedCommand.arguments !== undefined && parsedCommand.arguments.length > 0 ? parsedCommand.arguments : [];
+            const args = [id, ...commandArgs];
+            const customCallback: CustomCallback = {
+                label: 'AI command',
+                callback: () => this.commandCallback(...args),
+            };
+            return new HorizontalLayoutChatResponseContentImpl([
+                new MarkdownChatResponseContentImpl(
+                    'Try executing this:'
+                ),
+                new CommandChatResponseContentImpl(undefined, customCallback, args),
+            ]);
+        } else {
+            return new MarkdownChatResponseContentImpl(parsedCommand.message ?? 'Sorry, I can\'t find such a command');
+        }
+    }
+
+    protected async commandCallback(...commandArgs: unknown[]): Promise<void> {
+        this.messageService.info(`Executing callback with args ${commandArgs.join(', ')}. The first arg is the command id registered for the dynamically registered command. 
+        The other args are the actual args for the handler.`, 'Got it');
+    }
+}

package/src/common/index.ts

@@ -0,0 +1,24 @@
+// *****************************************************************************
+// 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
+// *****************************************************************************
+export * from './chat-agent-service';
+export * from './chat-agents';
+export * from './chat-model';
+export * from './parsed-chat-request';
+export * from './chat-request-parser';
+export * from './chat-service';
+export * from './command-chat-agents';
+export * from './universal-chat-agent';
+export * from './orchestrator-chat-agent';

package/src/common/orchestrator-chat-agent.ts

@@ -0,0 +1,151 @@
+// *****************************************************************************
+// 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 { AgentSpecificVariables, getJsonOfResponse, LanguageModelResponse } from '@theia/ai-core';
+import {
+    PromptTemplate
+} from '@theia/ai-core/lib/common';
+import { inject, injectable } from '@theia/core/shared/inversify';
+import { ChatAgentService } from './chat-agent-service';
+import { AbstractStreamParsingChatAgent, ChatAgent, SystemMessageDescription } from './chat-agents';
+import { ChatRequestModelImpl, InformationalChatResponseContentImpl } from './chat-model';
+
+export const orchestratorTemplate: PromptTemplate = {
+    id: 'orchestrator-system',
+    template: `# Instructions
+
+Your task is to identify which Chat Agent(s) should best reply a given user's message.
+You consider all messages of the conversation to ensure consistency and avoid agent switches without a clear context change.
+You should select the best Chat Agent based on the name and description of the agents, matching them to the user message.
+
+## Constraints
+
+Your response must be a JSON array containing the id(s) of the selected Chat Agent(s).
+
+* Do not use ids that are not provided in the list below.
+* Do not include any additional information, explanations, or questions for the user.
+* If there is no suitable choice, pick \`Universal\`.
+* If there are multiple good choices, return all of them.
+
+Unless there is a more specific agent available, select \`Universal\`, especially for general programming-related questions.
+You must only use the \`id\` attribute of the agent, never the name.
+
+### Example Results
+
+\`\`\`json
+["Universal"]
+\`\`\`
+
+\`\`\`json
+["AnotherChatAgent", "Universal"]
+\`\`\`
+
+## List of Currently Available Chat Agents
+
+{{chatAgents}}
+`};
+
+export const OrchestratorChatAgentId = 'Orchestrator';
+
+@injectable()
+export class OrchestratorChatAgent extends AbstractStreamParsingChatAgent implements ChatAgent {
+    name: string;
+    description: string;
+    readonly variables: string[];
+    promptTemplates: PromptTemplate[];
+    fallBackChatAgentId: string;
+    readonly functions: string[] = [];
+    readonly agentSpecificVariables: AgentSpecificVariables[] = [];
+
+    constructor() {
+        super(OrchestratorChatAgentId, [{
+            purpose: 'agent-selection',
+            identifier: 'openai/gpt-4o',
+        }], 'agent-selection', 'codicon codicon-symbol-boolean');
+        this.name = OrchestratorChatAgentId;
+        this.description = 'This agent analyzes the user request against the description of all available chat agents and selects the best fitting agent to answer the request \
+        (by using AI).The user\'s request will be directly delegated to the selected agent without further confirmation.';
+        this.variables = ['chatAgents'];
+        this.promptTemplates = [orchestratorTemplate];
+        this.fallBackChatAgentId = 'Universal';
+        this.functions = [];
+        this.agentSpecificVariables = [];
+    }
+
+    @inject(ChatAgentService)
+    protected chatAgentService: ChatAgentService;
+
+    override invoke(request: ChatRequestModelImpl): Promise<void> {
+        request.response.addProgressMessage({ content: 'Determining the most appropriate agent', status: 'inProgress' });
+        return super.invoke(request);
+    }
+
+    protected async getSystemMessageDescription(): Promise<SystemMessageDescription | undefined> {
+        const resolvedPrompt = await this.promptService.getPrompt(orchestratorTemplate.id);
+        return resolvedPrompt ? SystemMessageDescription.fromResolvedPromptTemplate(resolvedPrompt) : undefined;
+    }
+
+    protected override async addContentsToResponse(response: LanguageModelResponse, request: ChatRequestModelImpl): Promise<void> {
+        let agentIds: string[] = [];
+        try {
+            const jsonResponse = await getJsonOfResponse(response);
+            if (Array.isArray(jsonResponse)) {
+                agentIds = jsonResponse.filter((id: string) => id !== this.id);
+            }
+        } catch (error: unknown) {
+            // The llm sometimes does not return a parseable result
+            this.logger.error('Failed to parse JSON response', error);
+        }
+
+        if (agentIds.length < 1) {
+            this.logger.error('No agent was selected, delegating to fallback chat agent');
+            request.response.progressMessages.forEach(progressMessage =>
+                request.response.updateProgressMessage({ ...progressMessage, status: 'failed' })
+            );
+            agentIds = [this.fallBackChatAgentId];
+        }
+
+        // check if selected (or fallback) agent exists
+        if (!this.chatAgentService.getAgent(agentIds[0])) {
+            this.logger.error(`Chat agent ${agentIds[0]} not found. Falling back to first registered agent.`);
+            const firstRegisteredAgent = this.chatAgentService.getAgents().filter(a => a.id !== this.id)[0]?.id;
+            if (firstRegisteredAgent) {
+                agentIds = [firstRegisteredAgent];
+            } else {
+                throw new Error('No chat agent available to handle request. Please check your configuration whether any are enabled.');
+            }
+        }
+
+        // TODO support delegating to more than one agent
+        const delegatedToAgent = agentIds[0];
+        request.response.response.addContent(new InformationalChatResponseContentImpl(
+            `*Orchestrator*: Delegating to \`@${delegatedToAgent}\`
+            
+            ---
+
+            `
+        ));
+        request.response.overrideAgentId(delegatedToAgent);
+        request.response.progressMessages.forEach(progressMessage =>
+            request.response.updateProgressMessage({ ...progressMessage, status: 'completed' })
+        );
+        const agent = this.chatAgentService.getAgent(delegatedToAgent);
+        if (!agent) {
+            throw new Error(`Chat agent ${delegatedToAgent} not found.`);
+        }
+        await agent.invoke(request);
+    }
+}

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

@@ -0,0 +1,112 @@
+// *****************************************************************************
+// 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/chatParserTypes.ts
+// Partially copied from https://github.com/microsoft/vscode/blob/a2cab7255c0df424027be05d58e1b7b941f4ea60/src/vs/editor/common/core/offsetRange.ts
+
+import { AIVariable, ResolvedAIVariable, ToolRequest, toolRequestToPromptText } from '@theia/ai-core';
+import { ChatRequest } from './chat-model';
+
+export const chatVariableLeader = '#';
+export const chatAgentLeader = '@';
+export const chatFunctionLeader = '~';
+export const chatSubcommandLeader = '/';
+
+/**********************
+ * INTERFACES AND TYPE GUARDS
+ **********************/
+
+export interface OffsetRange {
+    readonly start: number;
+    readonly endExclusive: number;
+}
+
+export interface ParsedChatRequest {
+    readonly request: ChatRequest;
+    readonly parts: ParsedChatRequestPart[];
+    readonly toolRequests: Map<string, ToolRequest>;
+    readonly variables: Map<string, AIVariable>;
+}
+
+export interface ParsedChatRequestPart {
+    readonly kind: string;
+    /**
+     * The text as represented in the ChatRequest
+     */
+    readonly text: string;
+    /**
+     * The text as will be sent to the LLM
+     */
+    readonly promptText: string;
+
+    readonly range: OffsetRange;
+}
+
+export class ParsedChatRequestTextPart implements ParsedChatRequestPart {
+    readonly kind: 'text';
+
+    constructor(readonly range: OffsetRange, readonly text: string) { }
+
+    get promptText(): string {
+        return this.text;
+    }
+}
+
+export class ParsedChatRequestVariablePart implements ParsedChatRequestPart {
+    readonly kind: 'var';
+
+    public resolution: ResolvedAIVariable;
+
+    constructor(readonly range: OffsetRange, readonly variableName: string, readonly variableArg: string | undefined) { }
+
+    get text(): string {
+        const argPart = this.variableArg ? `:${this.variableArg}` : '';
+        return `${chatVariableLeader}${this.variableName}${argPart}`;
+    }
+
+    get promptText(): string {
+        return this.resolution?.value ?? this.text;
+    }
+}
+
+export class ParsedChatRequestFunctionPart implements ParsedChatRequestPart {
+    readonly kind: 'function';
+    constructor(readonly range: OffsetRange, readonly toolRequest: ToolRequest) { }
+
+    get text(): string {
+        return `${chatFunctionLeader}${this.toolRequest.id}`;
+    }
+
+    get promptText(): string {
+        return toolRequestToPromptText(this.toolRequest);
+    }
+}
+
+export class ParsedChatRequestAgentPart implements ParsedChatRequestPart {
+    readonly kind: 'agent';
+    constructor(readonly range: OffsetRange, readonly agentId: string, readonly agentName: string) { }
+
+    get text(): string {
+        return `${chatAgentLeader}${this.agentName}`;
+    }
+
+    get promptText(): string {
+        return '';
+    }
+}