@theia/ai-core 1.55.0 → 1.56.0

package/src/common/prompt-service.spec.ts

@@ -37,9 +37,10 @@ describe('PromptService', () => {
         container.bind<AIVariableService>(AIVariableService).toConstantValue(variableService);
 
         promptService = container.get<PromptService>(PromptService);
-        promptService.storePrompt('1', 'Hello, {{name}}!');
-        promptService.storePrompt('2', 'Goodbye, {{name}}!');
-        promptService.storePrompt('3', 'Ciao, {{invalid}}!');
+        promptService.storePromptTemplate({ id: '1', template: 'Hello, {{name}}!' });
+        promptService.storePromptTemplate({ id: '2', template: 'Goodbye, {{name}}!' });
+        promptService.storePromptTemplate({ id: '3', template: 'Ciao, {{invalid}}!' });
+        promptService.storePromptTemplate({ id: '8', template: 'Hello, {{{name}}}' });
     });
 
     it('should initialize prompts from PromptCollectionService', () => {
@@ -47,6 +48,7 @@ describe('PromptService', () => {
         expect(allPrompts['1'].template).to.equal('Hello, {{name}}!');
         expect(allPrompts['2'].template).to.equal('Goodbye, {{name}}!');
         expect(allPrompts['3'].template).to.equal('Ciao, {{invalid}}!');
+        expect(allPrompts['8'].template).to.equal('Hello, {{{name}}}');
     });
 
     it('should retrieve raw prompt by id', () => {
@@ -60,7 +62,7 @@ describe('PromptService', () => {
     });
 
     it('should store a new prompt', () => {
-        promptService.storePrompt('3', 'Welcome, {{name}}!');
+        promptService.storePromptTemplate({ id: '3', template: 'Welcome, {{name}}!' });
         const newPrompt = promptService.getRawPrompt('3');
         expect(newPrompt?.template).to.equal('Welcome, {{name}}!');
     });
@@ -86,13 +88,214 @@ describe('PromptService', () => {
     });
 
     it('should ignore whitespace in variables', async () => {
-        promptService.storePrompt('4', 'Hello, {{name }}!');
-        promptService.storePrompt('5', 'Hello, {{ name}}!');
-        promptService.storePrompt('6', 'Hello, {{ name }}!');
-        promptService.storePrompt('7', 'Hello, {{       name           }}!');
+        promptService.storePromptTemplate({ id: '4', template: 'Hello, {{name }}!' });
+        promptService.storePromptTemplate({ id: '5', template: 'Hello, {{ name}}!' });
+        promptService.storePromptTemplate({ id: '6', template: 'Hello, {{ name }}!' });
+        promptService.storePromptTemplate({ id: '7', template: 'Hello, {{       name           }}!' });
         for (let i = 4; i <= 7; i++) {
             const prompt = await promptService.getPrompt(`${i}`, { name: 'John' });
             expect(prompt?.text).to.equal('Hello, John!');
         }
     });
+
+    it('should retrieve raw prompt by id (three bracket)', () => {
+        const rawPrompt = promptService.getRawPrompt('8');
+        expect(rawPrompt?.template).to.equal('Hello, {{{name}}}');
+    });
+
+    it('should correctly replace variables (three brackets)', async () => {
+        const formattedPrompt = await promptService.getPrompt('8');
+        expect(formattedPrompt?.text).to.equal('Hello, Jane');
+    });
+
+    it('should ignore whitespace in variables (three bracket)', async () => {
+        promptService.storePromptTemplate({ id: '9', template: 'Hello, {{{name }}}' });
+        promptService.storePromptTemplate({ id: '10', template: 'Hello, {{{ name}}}' });
+        promptService.storePromptTemplate({ id: '11', template: 'Hello, {{{ name }}}' });
+        promptService.storePromptTemplate({ id: '12', template: 'Hello, {{{       name           }}}' });
+        for (let i = 9; i <= 12; i++) {
+            const prompt = await promptService.getPrompt(`${i}`, { name: 'John' });
+            expect(prompt?.text).to.equal('Hello, John');
+        }
+    });
+
+    it('should ignore invalid prompts with unmatched brackets', async () => {
+        promptService.storePromptTemplate({ id: '9', template: 'Hello, {{name' });
+        promptService.storePromptTemplate({ id: '10', template: 'Hello, {{{name' });
+        promptService.storePromptTemplate({ id: '11', template: 'Hello, name}}}}' });
+        const prompt1 = await promptService.getPrompt('9', { name: 'John' });
+        expect(prompt1?.text).to.equal('Hello, {{name'); // Not matching due to missing closing brackets
+        const prompt2 = await promptService.getPrompt('10', { name: 'John' });
+        expect(prompt2?.text).to.equal('Hello, {{{name'); // Matches pattern due to valid three-start-two-end brackets
+        const prompt3 = await promptService.getPrompt('11', { name: 'John' });
+        expect(prompt3?.text).to.equal('Hello, name}}}}'); // Extra closing bracket, does not match cleanly
+    });
+
+    it('should handle a mixture of two and three brackets correctly', async () => {
+        promptService.storePromptTemplate({ id: '12', template: 'Hi, {{name}}}' });            // (invalid)
+        promptService.storePromptTemplate({ id: '13', template: 'Hello, {{{name}}' });         // (invalid)
+        promptService.storePromptTemplate({ id: '14', template: 'Greetings, {{{name}}}}' });   // (invalid)
+        promptService.storePromptTemplate({ id: '15', template: 'Bye, {{{{name}}}' });         // (invalid)
+        promptService.storePromptTemplate({ id: '16', template: 'Ciao, {{{{name}}}}' });       // (invalid)
+        promptService.storePromptTemplate({ id: '17', template: 'Hi, {{name}}! {{{name}}}' }); // Mixed valid patterns
+
+        const prompt12 = await promptService.getPrompt('12', { name: 'John' });
+        expect(prompt12?.text).to.equal('Hi, {{name}}}');
+
+        const prompt13 = await promptService.getPrompt('13', { name: 'John' });
+        expect(prompt13?.text).to.equal('Hello, {{{name}}');
+
+        const prompt14 = await promptService.getPrompt('14', { name: 'John' });
+        expect(prompt14?.text).to.equal('Greetings, {{{name}}}}');
+
+        const prompt15 = await promptService.getPrompt('15', { name: 'John' });
+        expect(prompt15?.text).to.equal('Bye, {{{{name}}}');
+
+        const prompt16 = await promptService.getPrompt('16', { name: 'John' });
+        expect(prompt16?.text).to.equal('Ciao, {{{{name}}}}');
+
+        const prompt17 = await promptService.getPrompt('17', { name: 'John' });
+        expect(prompt17?.text).to.equal('Hi, John! John');
+    });
+
+    it('should strip single-line comments at the start of the template', () => {
+        promptService.storePromptTemplate({ id: 'comment-basic', template: '{{!-- Comment --}}Hello, {{name}}!' });
+        const prompt = promptService.getUnresolvedPrompt('comment-basic');
+        expect(prompt?.template).to.equal('Hello, {{name}}!');
+    });
+
+    it('should remove line break after first-line comment', () => {
+        promptService.storePromptTemplate({ id: 'comment-line-break', template: '{{!-- Comment --}}\nHello, {{name}}!' });
+        const prompt = promptService.getUnresolvedPrompt('comment-line-break');
+        expect(prompt?.template).to.equal('Hello, {{name}}!');
+    });
+
+    it('should strip multiline comments at the start of the template', () => {
+        promptService.storePromptTemplate({ id: 'comment-multiline', template: '{{!--\nMultiline comment\n--}}\nGoodbye, {{name}}!' });
+        const prompt = promptService.getUnresolvedPrompt('comment-multiline');
+        expect(prompt?.template).to.equal('Goodbye, {{name}}!');
+    });
+
+    it('should not strip comments not in the first line', () => {
+        promptService.storePromptTemplate({ id: 'comment-second-line', template: 'Hello, {{name}}!\n{{!-- Comment --}}' });
+        const prompt = promptService.getUnresolvedPrompt('comment-second-line');
+        expect(prompt?.template).to.equal('Hello, {{name}}!\n{{!-- Comment --}}');
+    });
+
+    it('should treat unclosed comments as regular text', () => {
+        promptService.storePromptTemplate({ id: 'comment-unclosed', template: '{{!-- Unclosed comment' });
+        const prompt = promptService.getUnresolvedPrompt('comment-unclosed');
+        expect(prompt?.template).to.equal('{{!-- Unclosed comment');
+    });
+
+    it('should treat standalone closing delimiters as regular text', () => {
+        promptService.storePromptTemplate({ id: 'comment-standalone', template: '--}} Hello, {{name}}!' });
+        const prompt = promptService.getUnresolvedPrompt('comment-standalone');
+        expect(prompt?.template).to.equal('--}} Hello, {{name}}!');
+    });
+
+    it('should handle nested comments and stop at the first closing tag', () => {
+        promptService.storePromptTemplate({ id: 'nested-comment', template: '{{!-- {{!-- Nested comment --}} --}}text' });
+        const prompt = promptService.getUnresolvedPrompt('nested-comment');
+        expect(prompt?.template).to.equal('--}}text');
+    });
+
+    it('should handle templates with only comments', () => {
+        promptService.storePromptTemplate({ id: 'comment-only', template: '{{!-- Only comments --}}' });
+        const prompt = promptService.getUnresolvedPrompt('comment-only');
+        expect(prompt?.template).to.equal('');
+    });
+
+    it('should handle mixed delimiters on the same line', () => {
+        promptService.storePromptTemplate({ id: 'comment-mixed', template: '{{!-- Unclosed comment --}}' });
+        const prompt = promptService.getUnresolvedPrompt('comment-mixed');
+        expect(prompt?.template).to.equal('');
+    });
+
+    it('should resolve variables after stripping single-line comments', async () => {
+        promptService.storePromptTemplate({ id: 'comment-resolve', template: '{{!-- Comment --}}Hello, {{name}}!' });
+        const prompt = await promptService.getPrompt('comment-resolve', { name: 'John' });
+        expect(prompt?.text).to.equal('Hello, John!');
+    });
+
+    it('should resolve variables in multiline templates with comments', async () => {
+        promptService.storePromptTemplate({ id: 'comment-multiline-vars', template: '{{!--\nMultiline comment\n--}}\nHello, {{name}}!' });
+        const prompt = await promptService.getPrompt('comment-multiline-vars', { name: 'John' });
+        expect(prompt?.text).to.equal('Hello, John!');
+    });
+
+    it('should resolve variables with standalone closing delimiters', async () => {
+        promptService.storePromptTemplate({ id: 'comment-standalone-vars', template: '--}} Hello, {{name}}!' });
+        const prompt = await promptService.getPrompt('comment-standalone-vars', { name: 'John' });
+        expect(prompt?.text).to.equal('--}} Hello, John!');
+    });
+
+    it('should treat unclosed comments as text and resolve variables', async () => {
+        promptService.storePromptTemplate({ id: 'comment-unclosed-vars', template: '{{!-- Unclosed comment\nHello, {{name}}!' });
+        const prompt = await promptService.getPrompt('comment-unclosed-vars', { name: 'John' });
+        expect(prompt?.text).to.equal('{{!-- Unclosed comment\nHello, John!');
+    });
+
+    it('should handle templates with mixed comments and variables', async () => {
+        promptService.storePromptTemplate({ id: 'comment-mixed-vars', template: '{{!-- Comment --}}Hi, {{name}}! {{!-- Another comment --}}' });
+        const prompt = await promptService.getPrompt('comment-mixed-vars', { name: 'John' });
+        expect(prompt?.text).to.equal('Hi, John! {{!-- Another comment --}}');
+    });
+
+    it('should return all variant IDs of a given prompt', () => {
+        promptService.storePromptTemplate({ id: 'main', template: 'Main template' });
+
+        promptService.storePromptTemplate({
+            id: 'variant1',
+            template: 'Variant 1',
+            variantOf: 'main'
+        });
+        promptService.storePromptTemplate({
+            id: 'variant2',
+            template: 'Variant 2',
+            variantOf: 'main'
+        });
+        promptService.storePromptTemplate({
+            id: 'variant3',
+            template: 'Variant 3',
+            variantOf: 'main'
+        });
+
+        const variantIds = promptService.getVariantIds('main');
+        expect(variantIds).to.deep.equal(['variant1', 'variant2', 'variant3']);
+    });
+
+    it('should return an empty array if no variants exist for a given prompt', () => {
+        promptService.storePromptTemplate({ id: 'main', template: 'Main template' });
+
+        const variantIds = promptService.getVariantIds('main');
+        expect(variantIds).to.deep.equal([]);
+    });
+
+    it('should return an empty array if the main prompt ID does not exist', () => {
+        const variantIds = promptService.getVariantIds('nonExistent');
+        expect(variantIds).to.deep.equal([]);
+    });
+
+    it('should not influence prompts without variants when other prompts have variants', () => {
+        promptService.storePromptTemplate({ id: 'mainWithVariants', template: 'Main template with variants' });
+        promptService.storePromptTemplate({ id: 'mainWithoutVariants', template: 'Main template without variants' });
+
+        promptService.storePromptTemplate({
+            id: 'variant1',
+            template: 'Variant 1',
+            variantOf: 'mainWithVariants'
+        });
+        promptService.storePromptTemplate({
+            id: 'variant2',
+            template: 'Variant 2',
+            variantOf: 'mainWithVariants'
+        });
+
+        const variantsForMainWithVariants = promptService.getVariantIds('mainWithVariants');
+        const variantsForMainWithoutVariants = promptService.getVariantIds('mainWithoutVariants');
+
+        expect(variantsForMainWithVariants).to.deep.equal(['variant1', 'variant2']);
+        expect(variantsForMainWithoutVariants).to.deep.equal([]);
+    });
 });

package/src/common/prompt-service.ts

@@ -20,11 +20,17 @@ import { AIVariableService } from './variable-service';
 import { ToolInvocationRegistry } from './tool-invocation-registry';
 import { toolRequestToPromptText } from './language-model-util';
 import { ToolRequest } from './language-model';
-import { PROMPT_VARIABLE_REGEX, PROMPT_FUNCTION_REGEX } from './prompt-service-util';
+import { matchFunctionsRegEx, matchVariablesRegEx } from './prompt-service-util';
+import { AISettingsService } from './settings-service';
 
 export interface PromptTemplate {
     id: string;
     template: string;
+    /**
+     * (Optional) The ID of the main template for which this template is a variant.
+     * If present, this indicates that the current template represents an alternative version of the specified main template.
+     */
+    variantOf?: string;
 }
 
 export interface PromptMap { [id: string]: PromptTemplate }
@@ -40,10 +46,15 @@ export interface ResolvedPromptTemplate {
 export const PromptService = Symbol('PromptService');
 export interface PromptService {
     /**
-     * Retrieve the raw {@link PromptTemplate} object.
+     * Retrieve the raw {@link PromptTemplate} object (unresolved variables, functions and including comments).
      * @param id the id of the {@link PromptTemplate}
      */
     getRawPrompt(id: string): PromptTemplate | undefined;
+    /**
+     * Retrieve the unresolved {@link PromptTemplate} object (unresolved variables, functions, excluding comments)
+     * @param id the id of the {@link PromptTemplate}
+     */
+    getUnresolvedPrompt(id: string): PromptTemplate | undefined;
     /**
      * Retrieve the default raw {@link PromptTemplate} object.
      * @param id the id of the {@link PromptTemplate}
@@ -58,11 +69,10 @@ export interface PromptService {
      */
     getPrompt(id: string, args?: { [key: string]: unknown }): Promise<ResolvedPromptTemplate | undefined>;
     /**
-     * Adds a prompt to the list of prompts.
-     * @param id the id of the prompt
-     * @param prompt the prompt template to store
+     * Adds a {@link PromptTemplate} to the list of prompts.
+     * @param promptTemplate the prompt template to store
      */
-    storePrompt(id: string, prompt: string): void;
+    storePromptTemplate(promptTemplate: PromptTemplate): void;
     /**
      * Removes a prompt from the list of prompts.
      * @param id the id of the prompt
@@ -72,6 +82,20 @@ export interface PromptService {
      * Return all known prompts as a {@link PromptMap map}.
      */
     getAllPrompts(): PromptMap;
+    /**
+     * Retrieve all variant IDs of a given {@link PromptTemplate}.
+     * @param id the id of the main {@link PromptTemplate}
+     * @returns an array of string IDs representing the variants of the given template
+     */
+    getVariantIds(id: string): string[];
+    /**
+     * Retrieve the currently selected variant ID for a given main prompt ID.
+     * If a variant is selected for the main prompt, it will be returned.
+     * Otherwise, the main prompt ID will be returned.
+     * @param id the id of the main prompt
+     * @returns the variant ID if one is selected, or the main prompt ID otherwise
+     */
+    getVariantId(id: string): Promise<string>;
 }
 
 export interface CustomAgentDescription {
@@ -112,6 +136,7 @@ export interface PromptCustomizationService {
      */
     getCustomizedPromptTemplate(id: string): string | undefined
 
+    getCustomPromptTemplateIDs(): string[];
     /**
      * Edit the template. If the content is specified, is will be
      * used to customize the template. Otherwise, the behavior depends
@@ -158,6 +183,9 @@ export interface PromptCustomizationService {
 
 @injectable()
 export class PromptServiceImpl implements PromptService {
+    @inject(AISettingsService) @optional()
+    protected readonly settingsService: AISettingsService | undefined;
+
     @inject(PromptCustomizationService) @optional()
     protected readonly customizationService: PromptCustomizationService | undefined;
 
@@ -181,13 +209,44 @@ export class PromptServiceImpl implements PromptService {
     getDefaultRawPrompt(id: string): PromptTemplate | undefined {
         return this._prompts[id];
     }
+
+    getUnresolvedPrompt(id: string): PromptTemplate | undefined {
+        const rawPrompt = this.getRawPrompt(id);
+        if (!rawPrompt) {
+            return undefined;
+        }
+        return {
+            id: rawPrompt.id,
+            template: this.stripComments(rawPrompt.template)
+        };
+    }
+
+    protected stripComments(template: string): string {
+        const commentRegex = /^\s*{{!--[\s\S]*?--}}\s*\n?/;
+        return commentRegex.test(template) ? template.replace(commentRegex, '').trimStart() : template;
+    }
+
+    async getVariantId(id: string): Promise<string> {
+        if (this.settingsService !== undefined) {
+            const agentSettingsMap = await this.settingsService.getSettings();
+
+            for (const agentSettings of Object.values(agentSettingsMap)) {
+                if (agentSettings.selectedVariants && agentSettings.selectedVariants[id]) {
+                    return agentSettings.selectedVariants[id];
+                }
+            }
+        }
+        return id;
+    }
+
     async getPrompt(id: string, args?: { [key: string]: unknown }): Promise<ResolvedPromptTemplate | undefined> {
-        const prompt = this.getRawPrompt(id);
+        const variantId = await this.getVariantId(id);
+        const prompt = this.getUnresolvedPrompt(variantId);
         if (prompt === undefined) {
             return undefined;
         }
 
-        const matches = [...prompt.template.matchAll(PROMPT_VARIABLE_REGEX)];
+        const matches = matchVariablesRegEx(prompt.template);
         const variableAndArgReplacements = await Promise.all(matches.map(async match => {
             const completeText = match[0];
             const variableAndArg = match[1];
@@ -207,7 +266,7 @@ export class PromptServiceImpl implements PromptService {
             };
         }));
 
-        const functionMatches = [...prompt.template.matchAll(PROMPT_FUNCTION_REGEX)];
+        const functionMatches = matchFunctionsRegEx(prompt.template);
         const functions = new Map<string, ToolRequest>();
         const functionReplacements = functionMatches.map(match => {
             const completeText = match[0];
@@ -252,10 +311,24 @@ export class PromptServiceImpl implements PromptService {
             return { ...this._prompts };
         }
     }
-    storePrompt(id: string, prompt: string): void {
-        this._prompts[id] = { id, template: prompt };
-    }
     removePrompt(id: string): void {
         delete this._prompts[id];
     }
+    getVariantIds(id: string): string[] {
+        const allCustomPromptTemplateIds = this.customizationService?.getCustomPromptTemplateIDs() || [];
+        const knownPromptIds = Object.keys(this._prompts);
+
+        // We filter out known IDs from the custom prompt template IDs, these are no variants, but customizations. Then we retain IDs that start with the main ID
+        const customVariantIds = allCustomPromptTemplateIds.filter(customId =>
+            !knownPromptIds.includes(customId) && customId.startsWith(id)
+        );
+        const variantIds = Object.values(this._prompts)
+            .filter(prompt => prompt.variantOf === id)
+            .map(variant => variant.id);
+
+        return [...variantIds, ...customVariantIds];
+    }
+    storePromptTemplate(promptTemplate: PromptTemplate): void {
+        this._prompts[promptTemplate.id] = promptTemplate;
+    }
 }

package/src/common/settings-service.ts

@@ -30,4 +30,9 @@ export type AISettings = Record<string, AgentSettings>;
 export interface AgentSettings {
     languageModelRequirements?: LanguageModelRequirement[];
     enable?: boolean;
+    /**
+     * A mapping of main template IDs to their selected variant IDs.
+     * If a main template is not present in this mapping, it means the main template is used.
+     */
+    selectedVariants?: Record<string, string>;
 }