@theia/ai-core 1.60.0-next.47 → 1.60.0

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

@@ -34,6 +34,38 @@ const templateEntry = {
     defaultLLM: 'openai/gpt-4o'
 };
 
+// Template source priorities (higher number = higher priority)
+// Higher priority will "override" lower priority templates
+const enum TemplatePriority {
+    GLOBAL_TEMPLATE_DIR = 1,
+    ADDITIONAL_TEMPLATE_DIR = 2,
+    TEMPLATE_FILE = 3
+}
+
+/**
+ * Interface defining properties that can be updated in the service
+ */
+export interface PromptCustomizationProperties {
+    /** Array of directory paths to load templates from */
+    directoryPaths?: string[];
+    /** Array of file paths to treat as templates */
+    filePaths?: string[];
+    /** Array of file extensions to consider as template files */
+    extensions?: string[];
+}
+
+interface TemplateEntry {
+    content: string;
+    priority: number;
+    sourceUri: string;
+    id: string;
+}
+
+interface WatchedFileInfo {
+    uri: URI;
+    templateId: string;
+}
+
 @injectable()
 export class FrontendPromptCustomizationServiceImpl implements PromptCustomizationService {
 
@@ -49,9 +81,21 @@ export class FrontendPromptCustomizationServiceImpl implements PromptCustomizati
     @inject(OpenerService)
     protected readonly openerService: OpenerService;
 
-    protected readonly trackedTemplateURIs = new Set<string>();
-    protected templates = new Map<string, string>();
-
+    /** Stores URI strings of template files from directories currently being monitored for changes. */
+    protected trackedTemplateURIs = new Set<string>();
+    /** Contains the currently active templates, mapped by template ID. */
+    protected effectiveTemplates = new Map<string, TemplateEntry>();
+    /** Tracks all loaded templates, including overridden ones, mapped by source URI. */
+    protected allLoadedTemplates = new Map<string, TemplateEntry>();
+    /** Stores additional directory paths for loading template files. */
+    protected additionalTemplateDirs = new Set<string>();
+    /** Contains file extensions that identify prompt template files. */
+    protected templateExtensions = new Set<string>([PROMPT_TEMPLATE_EXTENSION]);
+    /** Stores specific file paths that should be treated as templates. */
+    protected templateFiles = new Set<string>();
+    /** Maps URI strings to WatchedFileInfo objects for individually watched template files. */
+    protected watchedFiles = new Map<string, WatchedFileInfo>();
+    /** Collection of disposable resources for cleanup when the service updates or is disposed. */
     protected toDispose = new DisposableCollection();
 
     private readonly onDidChangePromptEmitter = new Emitter<string>();
@@ -62,6 +106,9 @@ export class FrontendPromptCustomizationServiceImpl implements PromptCustomizati
 
     @postConstruct()
     protected init(): void {
+        // Ensure PROMPT_TEMPLATE_EXTENSION is always included in templateExtensions as a default
+        this.templateExtensions.add(PROMPT_TEMPLATE_EXTENSION);
+
         this.preferences.onPreferenceChanged(event => {
             if (event.preferenceName === PREFERENCE_NAME_PROMPT_TEMPLATES) {
                 this.update();
@@ -72,55 +119,259 @@ export class FrontendPromptCustomizationServiceImpl implements PromptCustomizati
 
     protected async update(): Promise<void> {
         this.toDispose.dispose();
-        // we need to assign a local variable, so that updates running in parallel don't interfere with each other
-        const _templates = new Map<string, string>();
-        this.templates = _templates;
-        this.trackedTemplateURIs.clear();
+        // we need to assign local variables, so that updates running in parallel don't interfere with each other
+        const templatesMap = new Map<string, TemplateEntry>();
+        const trackedURIs = new Set<string>();
+        const loadedTemplates = new Map<string, TemplateEntry>();
+        const watchedFilesMap = new Map<string, WatchedFileInfo>();
 
+        // Process in order of priority (lowest to highest)
+        // First process the main template directory (lowest priority)
         const templateURI = await this.getTemplatesDirectoryURI();
+        await this.processTemplateDirectory(templatesMap, trackedURIs, loadedTemplates, templateURI, TemplatePriority.GLOBAL_TEMPLATE_DIR);
+
+        // Process additional template directories (medium priority)
+        for (const dirPath of this.additionalTemplateDirs) {
+            const dirURI = URI.fromFilePath(dirPath);
+            await this.processTemplateDirectory(templatesMap, trackedURIs, loadedTemplates, dirURI, TemplatePriority.ADDITIONAL_TEMPLATE_DIR);
+        }
+
+        // Process specific template files (highest priority)
+        await this.processTemplateFiles(templatesMap, trackedURIs, loadedTemplates, watchedFilesMap);
+
+        this.effectiveTemplates = templatesMap;
+        this.trackedTemplateURIs = trackedURIs;
+        this.allLoadedTemplates = loadedTemplates;
+        this.watchedFiles = watchedFilesMap;
+
+        this.onDidChangeCustomAgentsEmitter.fire();
+    }
+
+    /**
+     * Adds a template to the templates map, handling conflicts based on priority
+     * @param templatesMap The map to add the template to
+     * @param id The template ID
+     * @param content The template content
+     * @param priority The template priority
+     * @param sourceUri The URI of the source file (used to distinguish updates from conflicts)
+     * @param loadedTemplates The map to track all loaded templates
+     */
+    protected addTemplate(
+        templatesMap: Map<string, TemplateEntry>,
+        id: string,
+        content: string,
+        priority: number,
+        sourceUri: string,
+        loadedTemplates: Map<string, TemplateEntry>
+    ): void {
+        // Always add to loadedTemplates to keep track of all templates including overridden ones
+        if (sourceUri) {
+            loadedTemplates.set(sourceUri, { id, content, priority, sourceUri });
+        }
+
+        const existingEntry = templatesMap.get(id);
+
+        if (existingEntry) {
+            // If this is an update to the same file (same source URI)
+            if (sourceUri && existingEntry.sourceUri === sourceUri) {
+                // Update the content while keeping the same priority and source
+                templatesMap.set(id, { id, content, priority, sourceUri });
+                return;
+            }
+
+            // If the new template has higher priority, replace the existing one
+            if (priority > existingEntry.priority) {
+                templatesMap.set(id, { id, content, priority, sourceUri });
+                return;
+            } else if (priority === existingEntry.priority) {
+                // There is a conflict with the same priority, we ignore the new template
+                const conflictSourceUri = existingEntry.sourceUri ? ` (Existing source: ${existingEntry.sourceUri}, New source: ${sourceUri})` : '';
+                console.warn(`Template conflict detected for ID '${id}' with equal priority.${conflictSourceUri}`);
+            }
+            return;
+        }
+
+        // No conflict at all, add the template
+        templatesMap.set(id, { id, content, priority, sourceUri });
+    }
+
+    /**
+     * Removes a template from the templates map based on the source URI and fires change event.
+     * Also checks for any lower-priority templates with the same ID that might need to be loaded.
+     * @param sourceUri The URI of the source file being removed
+     * @param loadedTemplates The map of all loaded templates
+     */
+    protected removeTemplateBySourceUri(
+        sourceUri: string,
+        loadedTemplates: Map<string, TemplateEntry>
+    ): void {
+        // Get the template entry from loadedTemplates
+        const removedTemplate = loadedTemplates.get(sourceUri);
+        if (!removedTemplate) {
+            return;
+        }
+        const templateId = removedTemplate.id;
+        loadedTemplates.delete(sourceUri);
+
+        // If the template is in the active templates map, we check if there is another template previously conflicting with it
+        const activeTemplate = this.effectiveTemplates.get(templateId);
+        if (activeTemplate && activeTemplate.sourceUri === sourceUri) {
+            this.effectiveTemplates.delete(templateId);
+            // Find any lower-priority templates with the same ID that were previously ignored
+            const lowerPriorityTemplates = Array.from(loadedTemplates.values())
+                .filter(t => t.id === templateId)
+                .sort((a, b) => b.priority - a.priority); // Sort by priority (highest first)
+
+            // If there are any lower-priority templates, add the highest priority one
+            if (lowerPriorityTemplates.length > 0) {
+                const highestRemainingTemplate = lowerPriorityTemplates[0];
+                this.effectiveTemplates.set(templateId, highestRemainingTemplate);
+            }
+            this.onDidChangePromptEmitter.fire(templateId);
+        }
+    }
+
+    /**
+     * Process the template files specified by path, watching for changes
+     * and loading their content into the templates map
+     */
+    protected async processTemplateFiles(
+        templatesMap: Map<string, TemplateEntry>,
+        trackedURIs: Set<string>,
+        loadedTemplates: Map<string, TemplateEntry>,
+        watchedFilesMap: Map<string, WatchedFileInfo>
+    ): Promise<void> {
+
+        for (const filePath of this.templateFiles) {
+            const fileURI = URI.fromFilePath(filePath);
+            const templateId = this.getTemplateIdFromFilePath(filePath);
+            const uriString = fileURI.toString();
+
+            watchedFilesMap.set(uriString, { uri: fileURI, templateId });
+            this.toDispose.push(this.fileService.watch(fileURI, { recursive: false, excludes: [] }));
+
+            if (await this.fileService.exists(fileURI)) {
+                trackedURIs.add(uriString);
+                const fileContent = await this.fileService.read(fileURI);
+                this.addTemplate(templatesMap, templateId, fileContent.value, TemplatePriority.TEMPLATE_FILE, uriString, loadedTemplates);
+            }
+        }
 
-        this.toDispose.push(this.fileService.watch(templateURI, { recursive: true, excludes: [] }));
+        this.toDispose.push(this.fileService.onDidFilesChange(async (event: FileChangesEvent) => {
+
+            // Handle deleted files
+            for (const deletedFile of event.getDeleted()) {
+                const fileUriString = deletedFile.resource.toString();
+                const fileInfo = this.watchedFiles.get(fileUriString);
+
+                if (fileInfo) {
+                    this.removeTemplateBySourceUri(fileUriString, loadedTemplates);
+                    this.trackedTemplateURIs.delete(fileUriString);
+                    this.onDidChangePromptEmitter.fire(fileInfo.templateId);
+                }
+            }
+
+            // Handle updated files
+            for (const updatedFile of event.getUpdated()) {
+                const fileUriString = updatedFile.resource.toString();
+                const fileInfo = this.watchedFiles.get(fileUriString);
+
+                if (fileInfo) {
+                    const fileContent = await this.fileService.read(fileInfo.uri);
+                    this.addTemplate(
+                        this.effectiveTemplates,
+                        fileInfo.templateId,
+                        fileContent.value,
+                        TemplatePriority.TEMPLATE_FILE,
+                        fileUriString,
+                        loadedTemplates
+                    );
+                    this.onDidChangePromptEmitter.fire(fileInfo.templateId);
+                }
+            }
+
+            // Handle newly created files
+            for (const addedFile of event.getAdded()) {
+                const fileUriString = addedFile.resource.toString();
+                const fileInfo = this.watchedFiles.get(fileUriString);
+
+                if (fileInfo) {
+                    const fileContent = await this.fileService.read(fileInfo.uri);
+                    this.addTemplate(
+                        this.effectiveTemplates,
+                        fileInfo.templateId,
+                        fileContent.value,
+                        TemplatePriority.TEMPLATE_FILE,
+                        fileUriString,
+                        loadedTemplates
+                    );
+                    this.trackedTemplateURIs.add(fileUriString);
+                    this.onDidChangePromptEmitter.fire(fileInfo.templateId);
+                }
+            }
+        }));
+    }
+
+    /**
+     * Extract a template ID from a file path
+     * @param filePath The path to the template file
+     * @returns A template ID derived from the file name
+     */
+    protected getTemplateIdFromFilePath(filePath: string): string {
+        const uri = URI.fromFilePath(filePath);
+        return this.removePromptTemplateSuffix(uri.path.name);
+    }
+
+    protected async processTemplateDirectory(
+        templatesMap: Map<string, TemplateEntry>,
+        trackedURIs: Set<string>,
+        loadedTemplates: Map<string, TemplateEntry>,
+        dirURI: URI,
+        priority: TemplatePriority
+    ): Promise<void> {
+        this.toDispose.push(this.fileService.watch(dirURI, { 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())) {
                     this.trackedTemplateURIs.delete(deletedFile.resource.toString());
                     const templateId = this.removePromptTemplateSuffix(deletedFile.resource.path.name);
-                    _templates.delete(templateId);
+                    this.removeTemplateBySourceUri(deletedFile.resource.toString(), loadedTemplates);
                     this.onDidChangePromptEmitter.fire(templateId);
                 }
             }
+
             // 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 templateId = this.removePromptTemplateSuffix(updatedFile.resource.path.name);
-                    _templates.set(templateId, fileContent.value);
+                    this.addTemplate(this.effectiveTemplates, templateId, fileContent.value, priority, updatedFile.resource.toString(), loadedTemplates);
                     this.onDidChangePromptEmitter.fire(templateId);
                 }
             }
+
             // check new templates
             for (const addedFile of event.getAdded()) {
-                if (addedFile.resource.parent.toString() === templateURI.toString() && addedFile.resource.path.ext === PROMPT_TEMPLATE_EXTENSION) {
+                if (addedFile.resource.parent.toString() === dirURI.toString() &&
+                    this.isPromptTemplateExtension(addedFile.resource.path.ext)) {
                     this.trackedTemplateURIs.add(addedFile.resource.toString());
                     const fileContent = await this.fileService.read(addedFile.resource);
                     const templateId = this.removePromptTemplateSuffix(addedFile.resource.path.name);
-                    _templates.set(templateId, fileContent.value);
+                    this.addTemplate(this.effectiveTemplates, templateId, fileContent.value, priority, addedFile.resource.toString(), loadedTemplates);
                     this.onDidChangePromptEmitter.fire(templateId);
                 }
             }
-
         }));
 
-        this.onDidChangeCustomAgentsEmitter.fire();
-
-        if (!(await this.fileService.exists(templateURI))) {
+        if (!(await this.fileService.exists(dirURI))) {
             return;
         }
-        const stat = await this.fileService.resolve(templateURI);
+        const stat = await this.fileService.resolve(dirURI);
         if (stat.children === undefined) {
             return;
         }
@@ -130,14 +381,82 @@ export class FrontendPromptCustomizationServiceImpl implements PromptCustomizati
                 continue;
             }
             const fileURI = file.resource;
-            if (fileURI.path.ext === PROMPT_TEMPLATE_EXTENSION) {
-                this.trackedTemplateURIs.add(fileURI.toString());
+            if (this.isPromptTemplateExtension(fileURI.path.ext)) {
+                trackedURIs.add(fileURI.toString());
                 const fileContent = await this.fileService.read(fileURI);
                 const templateId = this.removePromptTemplateSuffix(file.name);
-                _templates.set(templateId, fileContent.value);
+                this.addTemplate(templatesMap, templateId, fileContent.value, priority, fileURI.toString(), loadedTemplates);
                 this.onDidChangePromptEmitter.fire(templateId);
             }
         }
+        this.onDidChangeCustomAgentsEmitter.fire();
+    }
+
+    /**
+     * Checks if the given file extension is registered as a prompt template extension
+     * @param extension The file extension including the leading dot (e.g., '.prompttemplate')
+     * @returns True if the extension is registered as a prompt template extension
+     */
+    protected isPromptTemplateExtension(extension: string): boolean {
+        return this.templateExtensions.has(extension);
+    }
+
+    /**
+     * Gets the list of additional template directories that are being watched.
+     * @returns Array of directory paths
+     */
+    getAdditionalTemplateDirectories(): string[] {
+        return Array.from(this.additionalTemplateDirs);
+    }
+
+    /**
+     * Gets the list of file extensions that are considered prompt templates.
+     * @returns Array of file extensions including the leading dot (e.g., '.prompttemplate')
+     */
+    getTemplateFileExtensions(): string[] {
+        return Array.from(this.templateExtensions);
+    }
+
+    /**
+     * Gets the list of specific template files that are being watched.
+     * @returns Array of file paths
+     */
+    getTemplateFiles(): string[] {
+        return Array.from(this.templateFiles);
+    }
+
+    /**
+     * Updates multiple configuration properties at once, triggering only a single update process.
+     *
+     * @param properties An object containing the properties to update
+     * @returns Promise that resolves when the update is complete
+     */
+    async updateConfiguration(properties: PromptCustomizationProperties): Promise<void> {
+        if (properties.directoryPaths !== undefined) {
+            this.additionalTemplateDirs.clear();
+            for (const path of properties.directoryPaths) {
+                this.additionalTemplateDirs.add(path);
+            }
+        }
+
+        if (properties.extensions !== undefined) {
+            this.templateExtensions.clear();
+            for (const ext of properties.extensions) {
+                this.templateExtensions.add(ext);
+            }
+            // Always include the default PROMPT_TEMPLATE_EXTENSION
+            this.templateExtensions.add(PROMPT_TEMPLATE_EXTENSION);
+        }
+
+        if (properties.filePaths !== undefined) {
+            this.templateFiles.clear();
+            for (const path of properties.filePaths) {
+                this.templateFiles.add(path);
+            }
+        }
+
+        // Only run the update process once, no matter how many properties were changed
+        await this.update();
     }
 
     protected async getTemplatesDirectoryURI(): Promise<URI> {
@@ -154,23 +473,25 @@ export class FrontendPromptCustomizationServiceImpl implements PromptCustomizati
     }
 
     protected removePromptTemplateSuffix(filename: string): string {
-        const suffix = PROMPT_TEMPLATE_EXTENSION;
-        if (filename.endsWith(suffix)) {
-            return filename.slice(0, -suffix.length);
+        for (const ext of this.templateExtensions) {
+            if (filename.endsWith(ext)) {
+                return filename.slice(0, -ext.length);
+            }
         }
         return filename;
     }
 
     isPromptTemplateCustomized(id: string): boolean {
-        return this.templates.has(id);
+        return this.effectiveTemplates.has(id);
     }
 
     getCustomizedPromptTemplate(id: string): string | undefined {
-        return this.templates.get(id);
+        const entry = this.effectiveTemplates.get(id);
+        return entry ? entry.content : undefined;
     }
 
     getCustomPromptTemplateIDs(): string[] {
-        return Array.from(this.templates.keys());
+        return Array.from(this.effectiveTemplates.keys());
     }
 
     async editTemplate(id: string, defaultContent?: string): Promise<void> {
@@ -191,7 +512,7 @@ export class FrontendPromptCustomizationServiceImpl implements PromptCustomizati
 
     getTemplateIDFromURI(uri: URI): string | undefined {
         const id = this.removePromptTemplateSuffix(uri.path.name);
-        if (this.templates.has(id)) {
+        if (this.effectiveTemplates.has(id)) {
             return id;
         }
         return undefined;

package/src/browser/index.ts

@@ -26,3 +26,4 @@ export * from './prompttemplate-contribution';
 export * from './theia-variable-contribution';
 export * from './frontend-variable-service';
 export * from './ai-core-command-contribution';
+export * from '../common/language-model-service';

package/src/browser/prompttemplate-contribution.ts

@@ -22,8 +22,9 @@ import { TabBarToolbarContribution, TabBarToolbarRegistry } from '@theia/core/li
 
 import { codicon, Widget } from '@theia/core/lib/browser';
 import { EditorWidget, ReplaceOperation } from '@theia/editor/lib/browser';
-import { PromptCustomizationService, PromptService, ToolInvocationRegistry } from '../common';
+import { PromptCustomizationService, PromptService, PromptText, ToolInvocationRegistry } from '../common';
 import { ProviderResult } from '@theia/monaco-editor-core/esm/vs/editor/common/languages';
+import { AIVariableService } from '../common/variable-service';
 
 const PROMPT_TEMPLATE_LANGUAGE_ID = 'theia-ai-prompt-template';
 const PROMPT_TEMPLATE_TEXTMATE_SCOPE = 'source.prompttemplate';
@@ -59,19 +60,28 @@ export class PromptTemplateContribution implements LanguageGrammarDefinitionCont
     @inject(ToolInvocationRegistry)
     protected readonly toolInvocationRegistry: ToolInvocationRegistry;
 
+    @inject(AIVariableService)
+    protected readonly variableService: AIVariableService;
+
     readonly config: monaco.languages.LanguageConfiguration =
         {
             'brackets': [
                 ['${', '}'],
-                ['~{', '}']
+                ['~{', '}'],
+                ['{{', '}}'],
+                ['{{{', '}}}']
             ],
             'autoClosingPairs': [
                 { 'open': '${', 'close': '}' },
                 { 'open': '~{', 'close': '}' },
+                { 'open': '{{', 'close': '}}' },
+                { 'open': '{{{', 'close': '}}}' }
             ],
             'surroundingPairs': [
                 { 'open': '${', 'close': '}' },
-                { 'open': '~{', 'close': '}' }
+                { 'open': '~{', 'close': '}' },
+                { 'open': '{{', 'close': '}}' },
+                { 'open': '{{{', 'close': '}}}' }
             ]
         };
 
@@ -95,6 +105,17 @@ export class PromptTemplateContribution implements LanguageGrammarDefinitionCont
             provideCompletionItems: (model, position, _context, _token): ProviderResult<monaco.languages.CompletionList> => this.provideFunctionCompletions(model, position),
         });
 
+        monaco.languages.registerCompletionItemProvider(PROMPT_TEMPLATE_LANGUAGE_ID, {
+            // Monaco only supports single character trigger characters
+            triggerCharacters: ['{'],
+            provideCompletionItems: (model, position, _context, _token): ProviderResult<monaco.languages.CompletionList> => this.provideVariableCompletions(model, position),
+        });
+        monaco.languages.registerCompletionItemProvider(PROMPT_TEMPLATE_LANGUAGE_ID, {
+            // Monaco only supports single character trigger characters
+            triggerCharacters: ['{', ':'],
+            provideCompletionItems: (model, position, _context, _token): ProviderResult<monaco.languages.CompletionList> => this.provideVariableWithArgCompletions(model, position),
+        });
+
         const textmateGrammar = require('../../data/prompttemplate.tmLanguage.json');
         const grammarDefinitionProvider: GrammarDefinitionProvider = {
             getGrammarDefinition: function (): Promise<GrammarDefinition> {
@@ -122,6 +143,62 @@ export class PromptTemplateContribution implements LanguageGrammarDefinitionCont
         );
     }
 
+    provideVariableCompletions(model: monaco.editor.ITextModel, position: monaco.Position): ProviderResult<monaco.languages.CompletionList> {
+        return this.getSuggestions(
+            model,
+            position,
+            '{{',
+            this.variableService.getVariables(),
+            monaco.languages.CompletionItemKind.Variable,
+            variable => variable.args?.some(arg => !arg.isOptional) ? variable.name + PromptText.VARIABLE_SEPARATOR_CHAR : variable.name,
+            variable => variable.name,
+            variable => variable.description ?? ''
+        );
+    }
+
+    async provideVariableWithArgCompletions(model: monaco.editor.ITextModel, position: monaco.Position): Promise<monaco.languages.CompletionList> {
+        // Get the text of the current line up to the cursor position
+        const textUntilPosition = model.getValueInRange({
+            startLineNumber: position.lineNumber,
+            startColumn: 1,
+            endLineNumber: position.lineNumber,
+            endColumn: position.column,
+        });
+
+        // Regex that captures the variable name in contexts like {{, {{{, {{varname, {{{varname, {{varname:, or {{{varname:
+        const variableRegex = /(?:\{\{\{|\{\{)([\w-]+)?(?::)?/;
+        const match = textUntilPosition.match(variableRegex);
+
+        if (!match) {
+            return { suggestions: [] };
+        }
+
+        const currentVariableName = match[1];
+        const hasColonSeparator = textUntilPosition.includes(`${currentVariableName}:`);
+
+        const variables = this.variableService.getVariables();
+        const suggestions: monaco.languages.CompletionItem[] = [];
+
+        for (const variable of variables) {
+            // If we have a variable:arg pattern, only process the matching variable
+            if (hasColonSeparator && variable.name !== currentVariableName) {
+                continue;
+            }
+
+            const provider = await this.variableService.getArgumentCompletionProvider(variable.name);
+            if (provider) {
+                const items = await provider(model, position, '{');
+                if (items) {
+                    suggestions.push(...items.map(item => ({
+                        ...item
+                    })));
+                }
+            }
+        }
+
+        return { suggestions };
+    }
+
     getCompletionRange(model: monaco.editor.ITextModel, position: monaco.Position, triggerCharacters: string): monaco.Range | undefined {
         // Check if the characters before the current position are the trigger characters
         const lineContent = model.getLineContent(position.lineNumber);