@theia/ai-core 1.59.0-next.72 → 1.60.0-next.43

package/src/browser/prompttemplate-contribution.ts

@@ -30,19 +30,19 @@ const PROMPT_TEMPLATE_TEXTMATE_SCOPE = 'source.prompttemplate';
 
 export const PROMPT_TEMPLATE_EXTENSION = '.prompttemplate';
 
-export const DISCARD_PROMPT_TEMPLATE_CUSTOMIZATIONS: Command = {
+export const DISCARD_PROMPT_TEMPLATE_CUSTOMIZATIONS: Command = Command.toLocalizedCommand({
     id: 'theia-ai-prompt-template:discard',
     iconClass: codicon('discard'),
     category: 'Theia AI Prompt Templates'
-};
+}, '', 'theia/ai/core/prompts/category');
 
 // TODO this command is mainly for testing purposes
-export const SHOW_ALL_PROMPTS_COMMAND: Command = {
+export const SHOW_ALL_PROMPTS_COMMAND: Command = Command.toLocalizedCommand({
     id: 'theia-ai-prompt-template:show-prompts-command',
     label: 'Show all prompts',
     iconClass: codicon('beaker'),
     category: 'Theia AI Prompt Templates',
-};
+}, 'theia/ai/core/showAllPrompts/label', 'theia/ai/core/prompts/category');
 
 @injectable()
 export class PromptTemplateContribution implements LanguageGrammarDefinitionContribution, CommandContribution, TabBarToolbarContribution {

package/src/browser/theia-variable-contribution.ts

@@ -24,6 +24,9 @@ import { AIVariableContribution, AIVariableResolver, AIVariableService, AIVariab
  */
 @injectable()
 export class TheiaVariableContribution implements AIVariableContribution, AIVariableResolver {
+
+    private static readonly THEIA_PREFIX = 'theia-';
+
     @inject(VariableResolverService)
     protected readonly variableResolverService: VariableResolverService;
 
@@ -33,8 +36,33 @@ export class TheiaVariableContribution implements AIVariableContribution, AIVari
     @inject(FrontendApplicationStateService)
     protected readonly stateService: FrontendApplicationStateService;
 
-    protected variableRenameMap: Map<string, string> = new Map([
-        ['file', 'currentFilePath'],
+    // Map original variable name to new name and description. If a mapped value is not present then the original will be kept.
+    // Only variables present in this map are registered.
+    protected variableRenameMap: Map<string, { name?: string, description?: string }> = new Map([
+        ['file', {
+            name: 'currentAbsoluteFilePath', description: nls.localize('theia/ai/core/variable-contribution/currentAbsoluteFilePath', 'The absolute path of the \
+            currently opened file. Please note that most agents will expect a relative file path (relative to the current workspace).')
+        }],
+        ['selectedText', {
+            description: nls.localize('theia/ai/core/variable-contribution/currentSelectedText', 'The plain text that is currently selected in the \
+            opened file. This excludes the information where the content is coming from. Please note that most agents will work better with a relative file path \
+            (relative to the current workspace).')
+        }],
+        ['currentText', {
+            name: 'currentFileContent', description: nls.localize('theia/ai/core/variable-contribution/currentFileContent', 'The plain content of the \
+            currently opened file. This excludes the information where the content is coming from. Please note that most agents will work better with a relative file path \
+            (relative to the current workspace).')
+        }],
+        ['relativeFile', {
+            name: 'currentRelativeFilePath', description: nls.localize('theia/ai/core/variable-contribution/currentRelativeFilePath', 'The relative path of the \
+            currently opened file.')
+        }],
+        ['relativeFileDirname', {
+            name: 'currentRelativeDirPath', description: nls.localize('theia/ai/core/variable-contribution/currentRelativeDirPath', 'The relative path of the directory \
+            containing the currently opened file.')
+        }],
+        ['lineNumber', {}],
+        ['workspaceFolder', {}]
     ]);
 
     registerVariables(service: AIVariableService): void {
@@ -42,21 +70,35 @@ export class TheiaVariableContribution implements AIVariableContribution, AIVari
             // some variable contributions in Theia are done as part of the onStart, same as our AI variable contributions
             // we therefore wait for all of them to be registered before we register we map them to our own
             this.variableRegistry.getVariables().forEach(variable => {
-                const variableName = this.variableRenameMap.has(variable.name) ? this.variableRenameMap.get(variable.name)! : variable.name;
+                if (!this.variableRenameMap.has(variable.name)) {
+                    return; // Do not register variables not part of the map
+                }
+                const mapping = this.variableRenameMap.get(variable.name)!;
+                const newName = (mapping.name && mapping.name.trim() !== '') ? mapping.name : variable.name;
+                const newDescription = (mapping.description && mapping.description.trim() !== '') ? mapping.description
+                    : (variable.description && variable.description.trim() !== '' ? variable.description
+                        : nls.localize('theia/ai/core/variable-contribution/builtInVariable', 'Theia Built-in Variable'));
+
                 service.registerResolver({
-                    id: `theia-${variable.name}`,
-                    name: variableName,
-                    description: variable.description ?? nls.localize('theia/ai/core/variable-contribution/builtInVariable', 'Theia Built-in Variable')
+                    id: `${TheiaVariableContribution.THEIA_PREFIX}${variable.name}`,
+                    name: newName,
+                    description: newDescription
                 }, this);
             });
         });
     }
 
     protected toTheiaVariable(request: AIVariableResolutionRequest): string {
-        return `$\{${request.variable.name}${request.arg ? ':' + request.arg : ''}}`;
+        // Remove the THEIA_PREFIX if present before constructing the variable string
+        const variableId = request.variable.id.startsWith(TheiaVariableContribution.THEIA_PREFIX) ? request.variable.id.slice(TheiaVariableContribution.THEIA_PREFIX.length) :
+            request.variable.id;
+        return `\${${variableId}${request.arg ? ':' + request.arg : ''}}`;
     }
 
     async canResolve(request: AIVariableResolutionRequest, context: AIVariableContext): Promise<number> {
+        if (!request.variable.id.startsWith(TheiaVariableContribution.THEIA_PREFIX)) {
+            return 0;
+        }
         // some variables are not resolvable without providing a specific context
         // this may be expensive but was not a problem for Theia's built-in variables
         const resolved = await this.variableResolverService.resolve(this.toTheiaVariable(request), context);
@@ -68,4 +110,3 @@ export class TheiaVariableContribution implements AIVariableContribution, AIVari
         return resolved ? { value: resolved, variable: request.variable } : undefined;
     }
 }
-

package/src/common/language-model.ts

@@ -32,7 +32,14 @@ export const isLanguageModelRequestMessage = (obj: unknown): obj is LanguageMode
         'query' in obj &&
         typeof (obj as { query: unknown }).query === 'string'
     );
-export type ToolRequestParametersProperties = Record<string, { type: string, [key: string]: unknown }>;
+
+export interface ToolRequestParameterProperty {
+    type?: string;
+    anyOf?: ToolRequestParameterProperty[];
+    [key: string]: unknown;
+}
+
+export type ToolRequestParametersProperties = Record<string, ToolRequestParameterProperty>;
 export interface ToolRequestParameters {
     type?: 'object';
     properties: ToolRequestParametersProperties;
@@ -48,17 +55,45 @@ export interface ToolRequest {
 }
 
 export namespace ToolRequest {
+    function isToolRequestParameterProperty(obj: unknown): obj is ToolRequestParameterProperty {
+        if (!obj || typeof obj !== 'object') {
+            return false;
+        }
+        const record = obj as Record<string, unknown>;
+
+        // Check that at least one of "type" or "anyOf" exists
+        if (!('type' in record) && !('anyOf' in record)) {
+            return false;
+        }
+
+        // If an "anyOf" field is present, it must be an array where each item is also a valid property.
+        if ('anyOf' in record) {
+            if (!Array.isArray(record.anyOf)) {
+                return false;
+            }
+            for (const item of record.anyOf) {
+                if (!isToolRequestParameterProperty(item)) {
+                    return false;
+                }
+            }
+        }
+        if ('type' in record && typeof record.type !== 'string') {
+            return false;
+        }
+
+        // No further checks required for additional properties.
+        return true;
+    }
     export function isToolRequestParametersProperties(obj: unknown): obj is ToolRequestParametersProperties {
-        if (!obj || typeof obj !== 'object') { return false; };
-
-        return Object.entries(obj).every(([key, value]) =>
-            typeof key === 'string' &&
-            value &&
-            typeof value === 'object' &&
-            'type' in value &&
-            typeof value.type === 'string' &&
-            Object.keys(value).every(k => typeof k === 'string')
-        );
+        if (!obj || typeof obj !== 'object') {
+            return false;
+        }
+        return Object.entries(obj).every(([key, value]) => {
+            if (typeof key !== 'string') {
+                return false;
+            }
+            return isToolRequestParameterProperty(value);
+        });
     }
     export function isToolRequestParameters(obj: unknown): obj is ToolRequestParameters {
         return !!obj && typeof obj === 'object' &&

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

@@ -20,6 +20,10 @@ import { expect } from 'chai';
 import { Container } from 'inversify';
 import { PromptService, PromptServiceImpl } from './prompt-service';
 import { DefaultAIVariableService, AIVariableService } from './variable-service';
+import { ToolInvocationRegistry } from './tool-invocation-registry';
+import { ToolRequest } from './language-model';
+import { Logger } from '@theia/core';
+import * as sinon from 'sinon';
 
 describe('PromptService', () => {
     let promptService: PromptService;
@@ -27,8 +31,9 @@ describe('PromptService', () => {
     beforeEach(() => {
         const container = new Container();
         container.bind<PromptService>(PromptService).to(PromptServiceImpl).inSingletonScope();
+        const logger = sinon.createStubInstance(Logger);
 
-        const variableService = new DefaultAIVariableService({ getContributions: () => [] });
+        const variableService = new DefaultAIVariableService({ getContributions: () => [] }, logger);
         const nameVariable = { id: 'test', name: 'name', description: 'Test name ' };
         variableService.registerResolver(nameVariable, {
             canResolve: () => 100,
@@ -298,4 +303,66 @@ describe('PromptService', () => {
         expect(variantsForMainWithVariants).to.deep.equal(['variant1', 'variant2']);
         expect(variantsForMainWithoutVariants).to.deep.equal([]);
     });
+
+    it('should resolve function references within resolved variable replacements', async () => {
+        // Mock the tool invocation registry
+        const toolInvocationRegistry = {
+            getFunction: sinon.stub()
+        };
+
+        // Create a test tool request that will be returned by the registry
+        const testFunction: ToolRequest = {
+            id: 'testFunction',
+            name: 'Test Function',
+            description: 'A test function',
+            parameters: {
+                type: 'object',
+                properties: {
+                    param1: {
+                        type: 'string',
+                        description: 'Test parameter'
+                    }
+                }
+            },
+            providerName: 'test-provider',
+            handler: sinon.stub()
+        };
+        toolInvocationRegistry.getFunction.withArgs('testFunction').returns(testFunction);
+
+        // Create a container with our mocked registry
+        const container = new Container();
+        container.bind<PromptService>(PromptService).to(PromptServiceImpl).inSingletonScope();
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        container.bind<ToolInvocationRegistry>(ToolInvocationRegistry).toConstantValue(toolInvocationRegistry as any);
+
+        // Set up a variable service that returns a fragment with a function reference
+        const variableService = new DefaultAIVariableService({ getContributions: () => [] }, sinon.createStubInstance(Logger));
+        const fragmentVariable = { id: 'test', name: 'fragment', description: 'Test fragment with function' };
+        variableService.registerResolver(fragmentVariable, {
+            canResolve: () => 100,
+            resolve: async () => ({
+                variable: fragmentVariable,
+                value: 'This fragment contains a function reference: ~{testFunction}'
+            })
+        });
+        container.bind<AIVariableService>(AIVariableService).toConstantValue(variableService);
+
+        const testPromptService = container.get<PromptService>(PromptService);
+        testPromptService.storePromptTemplate({ id: 'testPrompt', template: 'Template with fragment: {{fragment}}' });
+
+        // Get the resolved prompt
+        const resolvedPrompt = await testPromptService.getPrompt('testPrompt');
+
+        // Verify that the function was resolved
+        expect(resolvedPrompt).to.not.be.undefined;
+        expect(resolvedPrompt?.text).to.include('This fragment contains a function reference:');
+        expect(resolvedPrompt?.text).to.not.include('~{testFunction}');
+
+        // Verify that the function description was added to functionDescriptions
+        expect(resolvedPrompt?.functionDescriptions?.size).to.equal(1);
+        expect(resolvedPrompt?.functionDescriptions?.get('testFunction')).to.deep.equal(testFunction);
+
+        // Verify that the tool invocation registry was called
+        expect(toolInvocationRegistry.getFunction.calledWith('testFunction')).to.be.true;
+    });
 });

package/src/common/prompt-service.ts

@@ -16,7 +16,7 @@
 
 import { URI, Event } from '@theia/core';
 import { inject, injectable, optional } from '@theia/core/shared/inversify';
-import { AIVariableContext, AIVariableService } from './variable-service';
+import { AIVariableArg, AIVariableContext, AIVariableService, createAIResolveVariableCache, ResolvedAIVariable } from './variable-service';
 import { ToolInvocationRegistry } from './tool-invocation-registry';
 import { toolRequestToPromptText } from './language-model-util';
 import { ToolRequest } from './language-model';
@@ -41,6 +41,8 @@ export interface ResolvedPromptTemplate {
     text: string;
     /** All functions referenced in the prompt template. */
     functionDescriptions?: Map<string, ToolRequest>;
+    /** All variables resolved in the prompt template */
+    variables?: ResolvedAIVariable[];
 }
 
 export const PromptService = Symbol('PromptService');
@@ -64,10 +66,34 @@ export interface PromptService {
      * Allows to directly replace placeholders in the prompt. The supported format is 'Hi {{name}}!'.
      * The placeholder is then searched inside the args object and replaced.
      * Function references are also supported via format '~{functionId}'.
+     *
+     * All placeholders are replaced before function references are resolved.
+     * This allows to resolve function references contained in placeholders.
+     *
      * @param id the id of the prompt
      * @param args the object with placeholders, mapping the placeholder key to the value
      */
     getPrompt(id: string, args?: { [key: string]: unknown }, context?: AIVariableContext): Promise<ResolvedPromptTemplate | undefined>;
+
+    /**
+     * Allows to directly replace placeholders in the prompt. The supported format is 'Hi {{name}}!'.
+     * The placeholder is then searched inside the args object and replaced.
+     *
+     * In contrast to {@link getPrompt}, this method does not resolve function references but leaves them as is.
+     * This allows resolving them later as part of the prompt or chat message containing the fragment.
+     *
+     * @param id the id of the prompt
+     * @param args the object with placeholders, mapping the placeholder key to the value
+     * @param context the {@link AIVariableContext} to use during variable resolvement
+     * @param resolveVariable the variable resolving method. Fall back to using the {@link AIVariableService} if not given.
+     */
+    getPromptFragment(
+        id: string,
+        args?: { [key: string]: unknown },
+        context?: AIVariableContext,
+        resolveVariable?: (variable: AIVariableArg) => Promise<ResolvedAIVariable | undefined>
+    ): Promise<Omit<ResolvedPromptTemplate, 'functionDescriptions'> | undefined>;
+
     /**
      * Adds a {@link PromptTemplate} to the list of prompts.
      * @param promptTemplate the prompt template to store
@@ -246,27 +272,14 @@ export class PromptServiceImpl implements PromptService {
             return undefined;
         }
 
-        const matches = matchVariablesRegEx(prompt.template);
-        const variableAndArgReplacements = await Promise.all(matches.map(async match => {
-            const completeText = match[0];
-            const variableAndArg = match[1];
-            let variableName = variableAndArg;
-            let argument: string | undefined;
-            const parts = variableAndArg.split(':', 2);
-            if (parts.length > 1) {
-                variableName = parts[0];
-                argument = parts[1];
-            }
-            return {
-                placeholder: completeText,
-                value: String(args?.[variableAndArg] ?? (await this.variableService?.resolveVariable({
-                    variable: variableName,
-                    arg: argument
-                }, context ?? {}))?.value ?? completeText)
-            };
-        }));
+        // First resolve variables and arguments
+        let resolvedTemplate = prompt.template;
+        const variableAndArgReplacements = await this.getVariableAndArgReplacements(prompt.template, args, context);
+        variableAndArgReplacements.replacements.forEach(replacement => resolvedTemplate = resolvedTemplate.replace(replacement.placeholder, replacement.value));
 
-        const functionMatches = matchFunctionsRegEx(prompt.template);
+        // Then resolve function references with already resolved variables and arguments
+        // This allows to resolve function references contained in resolved variables (e.g. prompt fragments)
+        const functionMatches = matchFunctionsRegEx(resolvedTemplate);
         const functions = new Map<string, ToolRequest>();
         const functionReplacements = functionMatches.map(match => {
             const completeText = match[0];
@@ -280,16 +293,88 @@ export class PromptServiceImpl implements PromptService {
                 value: toolRequest ? toolRequestToPromptText(toolRequest) : completeText
             };
         });
+        functionReplacements.forEach(replacement => resolvedTemplate = resolvedTemplate.replace(replacement.placeholder, replacement.value));
+
+        return {
+            id,
+            text: resolvedTemplate,
+            functionDescriptions: functions.size > 0 ? functions : undefined,
+            variables: variableAndArgReplacements.resolvedVariables
+        };
+    }
 
+    async getPromptFragment(
+        id: string,
+        args?: { [key: string]: unknown },
+        context?: AIVariableContext,
+        resolveVariable?: (variable: AIVariableArg) => Promise<ResolvedAIVariable | undefined>
+    ): Promise<Omit<ResolvedPromptTemplate, 'functionDescriptions'> | undefined> {
+        const variantId = await this.getVariantId(id);
+        const prompt = this.getUnresolvedPrompt(variantId);
+        if (prompt === undefined) {
+            return undefined;
+        }
+
+        const replacements = await this.getVariableAndArgReplacements(prompt.template, args, context, resolveVariable);
         let resolvedTemplate = prompt.template;
-        const replacements = [...variableAndArgReplacements, ...functionReplacements];
-        replacements.forEach(replacement => resolvedTemplate = resolvedTemplate.replace(replacement.placeholder, replacement.value));
+        replacements.replacements.forEach(replacement => resolvedTemplate = resolvedTemplate.replace(replacement.placeholder, replacement.value));
+
         return {
             id,
             text: resolvedTemplate,
-            functionDescriptions: functions.size > 0 ? functions : undefined
+            variables: replacements.resolvedVariables
         };
     }
+
+    /**
+     * Calculates all variable and argument replacements for an unresolved template.
+     *
+     * @param template the unresolved template text
+     * @param args the object with placeholders, mapping the placeholder key to the value
+     * @param context the {@link AIVariableContext} to use during variable resolvement
+     * @param resolveVariable the variable resolving method. Fall back to using the {@link AIVariableService} if not given.
+     */
+    protected async getVariableAndArgReplacements(
+        template: string,
+        args?: { [key: string]: unknown },
+        context?: AIVariableContext,
+        resolveVariable?: (variable: AIVariableArg) => Promise<ResolvedAIVariable | undefined>
+    ): Promise<{ replacements: { placeholder: string; value: string }[], resolvedVariables: ResolvedAIVariable[] }> {
+        const matches = matchVariablesRegEx(template);
+        const variableCache = createAIResolveVariableCache();
+        const variableAndArgReplacements: { placeholder: string; value: string }[] = [];
+        const resolvedVariables: Set<ResolvedAIVariable> = new Set();
+        for (const match of matches) {
+            const completeText = match[0];
+            const variableAndArg = match[1];
+            let variableName = variableAndArg;
+            let argument: string | undefined;
+            const parts = variableAndArg.split(':', 2);
+            if (parts.length > 1) {
+                variableName = parts[0];
+                argument = parts[1];
+            }
+            let value: string;
+            if (args && args[variableAndArg] !== undefined) {
+                value = String(args[variableAndArg]);
+            } else {
+                const toResolve = { variable: variableName, arg: argument };
+                const resolved = resolveVariable
+                    ? await resolveVariable(toResolve)
+                    : await this.variableService?.resolveVariable(toResolve, context ?? {}, variableCache);
+                // Track resolved variable and its dependencies in all resolved variables
+                if (resolved) {
+                    resolvedVariables.add(resolved);
+                    resolved.allResolvedDependencies?.forEach(v => resolvedVariables.add(v));
+                }
+                value = String(resolved?.value ?? completeText);
+            }
+            variableAndArgReplacements.push({ placeholder: completeText, value });
+        }
+
+        return { replacements: variableAndArgReplacements, resolvedVariables: Array.from(resolvedVariables) };
+    }
+
     getAllPrompts(): PromptMap {
         if (this.customizationService !== undefined) {
             const myCustomization = this.customizationService;

package/src/common/prompt-variable-contribution.ts

@@ -0,0 +1,138 @@
+// *****************************************************************************
+// 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 { CommandService, nls } from '@theia/core';
+import { injectable, inject, optional } from '@theia/core/shared/inversify';
+import * as monaco from '@theia/monaco-editor-core';
+import {
+    AIVariable,
+    AIVariableContribution,
+    AIVariableService,
+    AIVariableResolutionRequest,
+    AIVariableContext,
+    ResolvedAIVariable,
+    AIVariableResolverWithVariableDependencies,
+    AIVariableArg
+} from './variable-service';
+import { PromptCustomizationService, PromptService } from './prompt-service';
+import { PromptText } from './prompt-text';
+
+export const PROMPT_VARIABLE: AIVariable = {
+    id: 'prompt-provider',
+    description: nls.localize('theia/ai/core/promptVariable/description', 'Resolves prompt templates via the prompt service'),
+    name: 'prompt',
+    args: [
+        { name: 'id', description: nls.localize('theia/ai/core/promptVariable/argDescription', 'The prompt template id to resolve') }
+    ]
+};
+
+@injectable()
+export class PromptVariableContribution implements AIVariableContribution, AIVariableResolverWithVariableDependencies {
+
+    @inject(CommandService)
+    protected readonly commandService: CommandService;
+
+    @inject(PromptService)
+    protected readonly promptService: PromptService;
+
+    @inject(PromptCustomizationService) @optional()
+    protected readonly promptCustomizationService: PromptCustomizationService;
+
+    registerVariables(service: AIVariableService): void {
+        service.registerResolver(PROMPT_VARIABLE, this);
+        service.registerArgumentPicker(PROMPT_VARIABLE, this.triggerArgumentPicker.bind(this));
+        service.registerArgumentCompletionProvider(PROMPT_VARIABLE, this.provideArgumentCompletionItems.bind(this));
+    }
+
+    canResolve(request: AIVariableResolutionRequest, context: AIVariableContext): number {
+        if (request.variable.name === PROMPT_VARIABLE.name) {
+            return 1;
+        }
+        return -1;
+    }
+
+    async resolve(
+        request: AIVariableResolutionRequest,
+        context: AIVariableContext,
+        resolveDependency?: (variable: AIVariableArg) => Promise<ResolvedAIVariable | undefined>
+    ): Promise<ResolvedAIVariable | undefined> {
+        if (request.variable.name === PROMPT_VARIABLE.name) {
+            const promptId = request.arg?.trim();
+            if (promptId) {
+                const resolvedPrompt = await this.promptService.getPromptFragment(promptId, undefined, context, resolveDependency);
+                if (resolvedPrompt) {
+                    return {
+                        variable: request.variable,
+                        value: resolvedPrompt.text,
+                        allResolvedDependencies: resolvedPrompt.variables
+                    };
+                }
+            }
+        }
+        return undefined;
+    }
+
+    protected async triggerArgumentPicker(): Promise<string | undefined> {
+        // Trigger the suggestion command to show argument completions
+        this.commandService.executeCommand('editor.action.triggerSuggest');
+        // Return undefined because we don't actually pick the argument here.
+        // The argument is selected and inserted by the monaco editor's completion mechanism.
+        return undefined;
+    }
+
+    protected async provideArgumentCompletionItems(
+        model: monaco.editor.ITextModel,
+        position: monaco.Position
+    ): Promise<monaco.languages.CompletionItem[] | undefined> {
+        const lineContent = model.getLineContent(position.lineNumber);
+
+        // Only provide completions once the variable argument separator is typed
+        const triggerCharIndex = lineContent.lastIndexOf(PromptText.VARIABLE_SEPARATOR_CHAR, position.column - 1);
+        if (triggerCharIndex === -1) {
+            return undefined;
+        }
+
+        // Check if the text immediately before the trigger is the prompt variable, i.e #prompt
+        const requiredVariable = `${PromptText.VARIABLE_CHAR}${PROMPT_VARIABLE.name}`;
+        if (triggerCharIndex < requiredVariable.length ||
+            lineContent.substring(triggerCharIndex - requiredVariable.length, triggerCharIndex) !== requiredVariable) {
+            return undefined;
+        }
+
+        const range = new monaco.Range(position.lineNumber, triggerCharIndex + 2, position.lineNumber, position.column);
+
+        const customPromptIds = this.promptCustomizationService?.getCustomPromptTemplateIDs() ?? [];
+        const builtinPromptIds = Object.keys(this.promptService.getAllPrompts());
+
+        const customPromptCompletions = customPromptIds.map(promptId => ({
+            label: promptId,
+            kind: monaco.languages.CompletionItemKind.Enum,
+            insertText: promptId,
+            range,
+            detail: nls.localize('theia/ai/core/promptVariable/completions/detail/custom', 'Custom prompt template'),
+            sortText: `AAA${promptId}` // Sort before everything else including all built-in prompts
+        }));
+        const builtinPromptCompletions = builtinPromptIds.map(promptId => ({
+            label: promptId,
+            kind: monaco.languages.CompletionItemKind.Variable,
+            insertText: promptId,
+            range,
+            detail: nls.localize('theia/ai/core/promptVariable/completions/detail/builtin', 'Built-in prompt template'),
+            sortText: `AAB${promptId}` // Sort after all custom prompts but before others
+        }));
+
+        return [...customPromptCompletions, ...builtinPromptCompletions];
+    }
+}