@theia/ai-core 1.55.0-next.4 → 1.55.0

package/src/browser/frontend-prompt-customization-service.ts

@@ -17,13 +17,22 @@
 import { DisposableCollection, URI, Event, Emitter } from '@theia/core';
 import { OpenerService } from '@theia/core/lib/browser';
 import { inject, injectable, postConstruct } from '@theia/core/shared/inversify';
-import { PromptCustomizationService, PromptTemplate } from '../common';
+import { PromptCustomizationService, CustomAgentDescription } from '../common';
 import { BinaryBuffer } from '@theia/core/lib/common/buffer';
 import { FileService } from '@theia/filesystem/lib/browser/file-service';
 import { FileChangesEvent } from '@theia/filesystem/lib/common/files';
 import { AICorePreferences, PREFERENCE_NAME_PROMPT_TEMPLATES } from './ai-core-preferences';
-import { AgentService } from '../common/agent-service';
 import { EnvVariablesServer } from '@theia/core/lib/common/env-variables';
+import { load, dump } from 'js-yaml';
+import { PROMPT_TEMPLATE_EXTENSION } from './prompttemplate-contribution';
+
+const templateEntry = {
+    id: 'my_agent',
+    name: 'My Agent',
+    description: 'This is an example agent. Please adapt the properties to fit your needs.',
+    prompt: 'You are an example agent. Be nice and helpful to the user.',
+    defaultLLM: 'openai/gpt-4o'
+};
 
 @injectable()
 export class FrontendPromptCustomizationServiceImpl implements PromptCustomizationService {
@@ -40,9 +49,6 @@ export class FrontendPromptCustomizationServiceImpl implements PromptCustomizati
     @inject(OpenerService)
     protected readonly openerService: OpenerService;
 
-    @inject(AgentService)
-    protected readonly agentService: AgentService;
-
     protected readonly trackedTemplateURIs = new Set<string>();
     protected templates = new Map<string, string>();
 
@@ -51,6 +57,9 @@ export class FrontendPromptCustomizationServiceImpl implements PromptCustomizati
     private readonly onDidChangePromptEmitter = new Emitter<string>();
     readonly onDidChangePrompt: Event<string> = this.onDidChangePromptEmitter.event;
 
+    private readonly onDidChangeCustomAgentsEmitter = new Emitter<void>();
+    readonly onDidChangeCustomAgents = this.onDidChangeCustomAgentsEmitter.event;
+
     @postConstruct()
     protected init(): void {
         this.preferences.onPreferenceChanged(event => {
@@ -72,6 +81,9 @@ export class FrontendPromptCustomizationServiceImpl implements PromptCustomizati
 
         this.toDispose.push(this.fileService.watch(templateURI, { recursive: true, excludes: [] }));
         this.toDispose.push(this.fileService.onDidFilesChange(async (event: FileChangesEvent) => {
+            if (event.changes.some(change => change.resource.toString().endsWith('customAgents.yml'))) {
+                this.onDidChangeCustomAgentsEmitter.fire();
+            }
             // check deleted templates
             for (const deletedFile of event.getDeleted()) {
                 if (this.trackedTemplateURIs.has(deletedFile.resource.toString())) {
@@ -84,25 +96,26 @@ export class FrontendPromptCustomizationServiceImpl implements PromptCustomizati
             // check updated templates
             for (const updatedFile of event.getUpdated()) {
                 if (this.trackedTemplateURIs.has(updatedFile.resource.toString())) {
-                    const filecontent = await this.fileService.read(updatedFile.resource);
+                    const fileContent = await this.fileService.read(updatedFile.resource);
                     const templateId = this.removePromptTemplateSuffix(updatedFile.resource.path.name);
-                    _templates.set(templateId, filecontent.value);
+                    _templates.set(templateId, fileContent.value);
                     this.onDidChangePromptEmitter.fire(templateId);
                 }
             }
             // check new templates
             for (const addedFile of event.getAdded()) {
-                if (addedFile.resource.parent.toString() === templateURI.toString() && addedFile.resource.path.ext === '.prompttemplate') {
+                if (addedFile.resource.parent.toString() === templateURI.toString() && addedFile.resource.path.ext === PROMPT_TEMPLATE_EXTENSION) {
                     this.trackedTemplateURIs.add(addedFile.resource.toString());
-                    const filecontent = await this.fileService.read(addedFile.resource);
+                    const fileContent = await this.fileService.read(addedFile.resource);
                     const templateId = this.removePromptTemplateSuffix(addedFile.resource.path.name);
-                    _templates.set(templateId, filecontent.value);
+                    _templates.set(templateId, fileContent.value);
                     this.onDidChangePromptEmitter.fire(templateId);
                 }
             }
 
         }));
 
+        this.onDidChangeCustomAgentsEmitter.fire();
         const stat = await this.fileService.resolve(templateURI);
         if (stat.children === undefined) {
             return;
@@ -113,11 +126,11 @@ export class FrontendPromptCustomizationServiceImpl implements PromptCustomizati
                 continue;
             }
             const fileURI = file.resource;
-            if (fileURI.path.ext === '.prompttemplate') {
+            if (fileURI.path.ext === PROMPT_TEMPLATE_EXTENSION) {
                 this.trackedTemplateURIs.add(fileURI.toString());
-                const filecontent = await this.fileService.read(fileURI);
+                const fileContent = await this.fileService.read(fileURI);
                 const templateId = this.removePromptTemplateSuffix(file.name);
-                _templates.set(templateId, filecontent.value);
+                _templates.set(templateId, fileContent.value);
                 this.onDidChangePromptEmitter.fire(templateId);
             }
         }
@@ -133,11 +146,11 @@ export class FrontendPromptCustomizationServiceImpl implements PromptCustomizati
     }
 
     protected async getTemplateURI(templateId: string): Promise<URI> {
-        return (await this.getTemplatesDirectoryURI()).resolve(`${templateId}.prompttemplate`);
+        return (await this.getTemplatesDirectoryURI()).resolve(`${templateId}${PROMPT_TEMPLATE_EXTENSION}`);
     }
 
     protected removePromptTemplateSuffix(filename: string): string {
-        const suffix = '.prompttemplate';
+        const suffix = PROMPT_TEMPLATE_EXTENSION;
         if (filename.endsWith(suffix)) {
             return filename.slice(0, -suffix.length);
         }
@@ -152,17 +165,10 @@ export class FrontendPromptCustomizationServiceImpl implements PromptCustomizati
         return this.templates.get(id);
     }
 
-    async editTemplate(id: string, content?: string): Promise<void> {
-        const template = this.getOriginalTemplate(id);
-        if (template === undefined) {
-            throw new Error(`Unable to edit template ${id}: template not found.`);
-        }
+    async editTemplate(id: string, defaultContent?: string): Promise<void> {
         const editorUri = await this.getTemplateURI(id);
         if (! await this.fileService.exists(editorUri)) {
-            await this.fileService.createFile(editorUri, BinaryBuffer.fromString(content ?? template.template));
-        } else if (content) {
-            // Write content to the file before opening it
-            await this.fileService.writeFile(editorUri, BinaryBuffer.fromString(content));
+            await this.fileService.createFile(editorUri, BinaryBuffer.fromString(defaultContent ?? ''));
         }
         const openHandler = await this.openerService.getOpener(editorUri);
         openHandler.open(editorUri);
@@ -175,17 +181,6 @@ export class FrontendPromptCustomizationServiceImpl implements PromptCustomizati
         }
     }
 
-    getOriginalTemplate(id: string): PromptTemplate | undefined {
-        for (const agent of this.agentService.getAllAgents()) {
-            for (const template of agent.promptTemplates) {
-                if (template.id === id) {
-                    return template;
-                }
-            }
-        }
-        return undefined;
-    }
-
     getTemplateIDFromURI(uri: URI): string | undefined {
         const id = this.removePromptTemplateSuffix(uri.path.name);
         if (this.templates.has(id)) {
@@ -194,4 +189,47 @@ export class FrontendPromptCustomizationServiceImpl implements PromptCustomizati
         return undefined;
     }
 
+    async getCustomAgents(): Promise<CustomAgentDescription[]> {
+        const customAgentYamlUri = (await this.getTemplatesDirectoryURI()).resolve('customAgents.yml');
+        const yamlExists = await this.fileService.exists(customAgentYamlUri);
+        if (!yamlExists) {
+            return [];
+        }
+        const fileContent = await this.fileService.read(customAgentYamlUri, { encoding: 'utf-8' });
+        try {
+            const doc = load(fileContent.value);
+            if (!Array.isArray(doc) || !doc.every(entry => CustomAgentDescription.is(entry))) {
+                console.debug('Invalid customAgents.yml file content');
+                return [];
+            }
+            const readAgents = doc as CustomAgentDescription[];
+            // make sure all agents are unique (id and name)
+            const uniqueAgentIds = new Set<string>();
+            const uniqueAgents: CustomAgentDescription[] = [];
+            readAgents.forEach(agent => {
+                if (uniqueAgentIds.has(agent.id)) {
+                    return;
+                }
+                uniqueAgentIds.add(agent.id);
+                uniqueAgents.push(agent);
+            });
+            return uniqueAgents;
+        } catch (e) {
+            console.debug(e.message, e);
+            return [];
+        }
+    }
+
+    async openCustomAgentYaml(): Promise<void> {
+        const customAgentYamlUri = (await this.getTemplatesDirectoryURI()).resolve('customAgents.yml');
+        const content = dump([templateEntry]);
+        if (! await this.fileService.exists(customAgentYamlUri)) {
+            await this.fileService.createFile(customAgentYamlUri, BinaryBuffer.fromString(content));
+        } else {
+            const fileContent = (await this.fileService.readFile(customAgentYamlUri)).value;
+            await this.fileService.writeFile(customAgentYamlUri, BinaryBuffer.concat([fileContent, BinaryBuffer.fromString(content)]));
+        }
+        const openHandler = await this.openerService.getOpener(customAgentYamlUri);
+        openHandler.open(customAgentYamlUri);
+    }
 }

package/src/browser/prompttemplate-contribution.ts

@@ -28,6 +28,8 @@ import { ProviderResult } from '@theia/monaco-editor-core/esm/vs/editor/common/l
 const PROMPT_TEMPLATE_LANGUAGE_ID = 'theia-ai-prompt-template';
 const PROMPT_TEMPLATE_TEXTMATE_SCOPE = 'source.prompttemplate';
 
+export const PROMPT_TEMPLATE_EXTENSION = '.prompttemplate';
+
 export const DISCARD_PROMPT_TEMPLATE_CUSTOMIZATIONS: Command = {
     id: 'theia-ai-prompt-template:discard',
     iconClass: codicon('discard'),
@@ -81,7 +83,7 @@ export class PromptTemplateContribution implements LanguageGrammarDefinitionCont
                 'Theia AI Prompt Templates'
             ],
             'extensions': [
-                '.prompttemplate',
+                PROMPT_TEMPLATE_EXTENSION,
             ],
             'filenames': []
         });

package/src/browser/style/index.css

@@ -88,3 +88,8 @@
   border-radius: calc(var(--theia-ui-padding) * 2 / 3);
   background: hsla(0, 0%, 68%, 0.31);
 }
+
+.configuration-agents-add {
+  margin-top: 3em;
+  margin-left: 0;
+}

package/src/common/agent-service.ts

@@ -13,10 +13,11 @@
 //
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
-import { inject, injectable, named, optional, postConstruct } from '@theia/core/shared/inversify';
-import { ContributionProvider } from '@theia/core';
+import { inject, injectable, optional, postConstruct } from '@theia/core/shared/inversify';
+import { Emitter, Event } from '@theia/core';
 import { Agent } from './agent';
 import { AISettingsService } from './settings-service';
+import { PromptService } from './prompt-service';
 
 export const AgentService = Symbol('AgentService');
 
@@ -48,21 +49,42 @@ export interface AgentService {
      * @return true if the agent is enabled, false otherwise.
      */
     isEnabled(agentId: string): boolean;
+
+    /**
+     * Allows to register an agent programmatically.
+     * @param agent the agent to register
+     */
+    registerAgent(agent: Agent): void;
+
+    /**
+     * Allows to unregister an agent programmatically.
+     * @param agentId the agent id to unregister
+     */
+    unregisterAgent(agentId: string): void;
+
+    /**
+     * Emitted when the list of agents changes.
+     * This can be used to update the UI when agents are added or removed.
+     */
+    onDidChangeAgents: Event<void>;
 }
 
 @injectable()
 export class AgentServiceImpl implements AgentService {
 
-    @inject(ContributionProvider) @named(Agent)
-    protected readonly agentsProvider: ContributionProvider<Agent>;
-
     @inject(AISettingsService) @optional()
     protected readonly aiSettingsService: AISettingsService | undefined;
 
+    @inject(PromptService)
+    protected readonly promptService: PromptService;
+
     protected disabledAgents = new Set<string>();
 
     protected _agents: Agent[] = [];
 
+    private readonly onDidChangeAgentsEmitter = new Emitter<void>();
+    readonly onDidChangeAgents = this.onDidChangeAgentsEmitter.event;
+
     @postConstruct()
     protected init(): void {
         this.aiSettingsService?.getSettings().then(settings => {
@@ -74,22 +96,29 @@ export class AgentServiceImpl implements AgentService {
         });
     }
 
-    private get agents(): Agent[] {
-        // We can't collect the contributions at @postConstruct because this will lead to a circular dependency
-        // with agents reusing the chat agent service (e.g. orchestrator) which in turn injects the agent service
-        return [...this.agentsProvider.getContributions(), ...this._agents];
-    }
-
     registerAgent(agent: Agent): void {
         this._agents.push(agent);
+        agent.promptTemplates.forEach(
+            template => this.promptService.storePrompt(template.id, template.template)
+        );
+        this.onDidChangeAgentsEmitter.fire();
+    }
+
+    unregisterAgent(agentId: string): void {
+        const agent = this._agents.find(a => a.id === agentId);
+        this._agents = this._agents.filter(a => a.id !== agentId);
+        this.onDidChangeAgentsEmitter.fire();
+        agent?.promptTemplates.forEach(
+            template => this.promptService.removePrompt(template.id)
+        );
     }
 
     getAgents(): Agent[] {
-        return this.agents.filter(agent => this.isEnabled(agent.id));
+        return this._agents.filter(agent => this.isEnabled(agent.id));
     }
 
     getAllAgents(): Agent[] {
-        return this.agents;
+        return this._agents;
     }
 
     enableAgent(agentId: string): void {

package/src/common/communication-recording-service.ts

@@ -41,4 +41,9 @@ export interface CommunicationRecordingService {
     readonly onDidRecordResponse: Event<CommunicationResponseEntry>;
 
     getHistory(agentId: string): CommunicationHistory;
+
+    getSessionHistory(sessionId: string): CommunicationHistory;
+
+    clearHistory(): void;
+    readonly onStructuralChange: Event<void>;
 }

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

@@ -14,8 +14,18 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 
-import { isLanguageModelStreamResponse, isLanguageModelTextResponse, LanguageModelResponse, ToolRequest } from './language-model';
+import { isLanguageModelParsedResponse, isLanguageModelStreamResponse, isLanguageModelTextResponse, LanguageModelResponse, ToolRequest } from './language-model';
 
+/**
+ * Retrieves the text content from a `LanguageModelResponse` object.
+ *
+ * **Important:** For stream responses, the stream can only be consumed once. Calling this function multiple times on the same stream response will return an empty string (`''`)
+ * on subsequent calls, as the stream will have already been consumed.
+ *
+ * @param {LanguageModelResponse} response - The response object, which may contain a text, stream, or parsed response.
+ * @returns {Promise<string>} - A promise that resolves to the text content of the response.
+ * @throws {Error} - Throws an error if the response type is not supported or does not contain valid text content.
+ */
 export const getTextOfResponse = async (response: LanguageModelResponse): Promise<string> => {
     if (isLanguageModelTextResponse(response)) {
         return response.text;
@@ -25,12 +35,18 @@ export const getTextOfResponse = async (response: LanguageModelResponse): Promis
             result += chunk.content ?? '';
         }
         return result;
+    } else if (isLanguageModelParsedResponse(response)) {
+        return response.content;
     }
     throw new Error(`Invalid response type ${response}`);
 };
 
 export const getJsonOfResponse = async (response: LanguageModelResponse): Promise<unknown> => {
     const text = await getTextOfResponse(response);
+    return getJsonOfText(text);
+};
+
+export const getJsonOfText = (text: string): unknown => {
     if (text.startsWith('```json')) {
         const regex = /```json\s*([\s\S]*?)\s*```/g;
         let match;
@@ -47,6 +63,7 @@ export const getJsonOfResponse = async (response: LanguageModelResponse): Promis
     }
     throw new Error('Invalid response format');
 };
+
 export const toolRequestToPromptText = (toolRequest: ToolRequest): string => {
     const parameters = toolRequest.parameters;
     let paramsText = '';

package/src/common/prompt-service.ts

@@ -58,17 +58,46 @@ export interface PromptService {
      */
     getPrompt(id: string, args?: { [key: string]: unknown }): Promise<ResolvedPromptTemplate | undefined>;
     /**
-     * Manually add a prompt to the list of prompts.
+     * Adds a prompt to the list of prompts.
      * @param id the id of the prompt
      * @param prompt the prompt template to store
      */
     storePrompt(id: string, prompt: string): void;
+    /**
+     * Removes a prompt from the list of prompts.
+     * @param id the id of the prompt
+     */
+    removePrompt(id: string): void;
     /**
      * Return all known prompts as a {@link PromptMap map}.
      */
     getAllPrompts(): PromptMap;
 }
 
+export interface CustomAgentDescription {
+    id: string;
+    name: string;
+    description: string;
+    prompt: string;
+    defaultLLM: string;
+}
+export namespace CustomAgentDescription {
+    export function is(entry: unknown): entry is CustomAgentDescription {
+        // eslint-disable-next-line no-null/no-null
+        return typeof entry === 'object' && entry !== null
+            && 'id' in entry && typeof entry.id === 'string'
+            && 'name' in entry && typeof entry.name === 'string'
+            && 'description' in entry && typeof entry.description === 'string'
+            && 'prompt' in entry
+            && typeof entry.prompt === 'string'
+            && 'defaultLLM' in entry
+            && typeof entry.defaultLLM === 'string';
+    }
+    export function equals(a: CustomAgentDescription, b: CustomAgentDescription): boolean {
+        return a.id === b.id && a.name === b.name && a.description === b.description && a.prompt === b.prompt && a.defaultLLM === b.defaultLLM;
+    }
+}
+
 export const PromptCustomizationService = Symbol('PromptCustomizationService');
 export interface PromptCustomizationService {
     /**
@@ -89,9 +118,9 @@ export interface PromptCustomizationService {
      * on the implementation. Implementation may for example decide to
      * open an editor, or request more information from the user, ...
      * @param id the template id.
-     * @param content optional content to customize the template.
+     * @param content optional default content to initialize the template
      */
-    editTemplate(id: string, content?: string): void;
+    editTemplate(id: string, defaultContent?: string): void;
 
     /**
      * Reset the template to its default value.
@@ -109,6 +138,22 @@ export interface PromptCustomizationService {
      * Event which is fired when the prompt template is changed.
      */
     readonly onDidChangePrompt: Event<string>;
+
+    /**
+     * Return all custom agents.
+     * @returns all custom agents
+     */
+    getCustomAgents(): Promise<CustomAgentDescription[]>;
+
+    /**
+     * Event which is fired when custom agents are modified.
+     */
+    readonly onDidChangeCustomAgents: Event<void>;
+
+    /**
+     * Open the custom agent yaml file.
+     */
+    openCustomAgentYaml(): void;
 }
 
 @injectable()
@@ -210,4 +255,7 @@ export class PromptServiceImpl implements PromptService {
     storePrompt(id: string, prompt: string): void {
         this._prompts[id] = { id, template: prompt };
     }
+    removePrompt(id: string): void {
+        delete this._prompts[id];
+    }
 }