Allow chat templates in config plugins (#537)

app/MindWork AI Studio/Tools/PluginSystem/PluginConfiguration.cs

@@ -1,5 +1,6 @@
 using AIStudio.Provider;
 using AIStudio.Settings;
+using AIStudio.Chat;
 
 using Lua;
 
@@ -13,7 +14,14 @@ public sealed class PluginConfiguration(bool isInternal, LuaState state, PluginT
     private static string TB(string fallbackEN) => I18N.I.T(fallbackEN, typeof(PluginConfiguration).Namespace, nameof(PluginConfiguration));
     private static readonly ILogger<PluginConfiguration> LOGGER = Program.LOGGER_FACTORY.CreateLogger<PluginConfiguration>();
     private static readonly SettingsManager SETTINGS_MANAGER = Program.SERVICE_PROVIDER.GetRequiredService<SettingsManager>();
-
+    
+    private readonly List<PluginConfigurationObject> configObjects = [];
+    
+    /// <summary>
+    /// The list of configuration objects. Configuration objects are, e.g., providers or chat templates. 
+    /// </summary>
+    public IEnumerable<PluginConfigurationObject> ConfigObjects => this.configObjects;
+    
     public async Task InitializeAsync(bool dryRun)
     {
         if(!this.TryProcessConfiguration(dryRun, out var issue))
@@ -29,11 +37,13 @@ public sealed class PluginConfiguration(bool isInternal, LuaState state, PluginT
     /// <summary>
     /// Tries to initialize the UI text content of the plugin.
     /// </summary>
-    /// <param name="dryRun">When true, the method will not apply any changes, but only check if the configuration can be read.</param>
+    /// <param name="dryRun">When true, the method will not apply any changes but only check if the configuration can be read.</param>
     /// <param name="message">The error message, when the UI text content could not be read.</param>
     /// <returns>True, when the UI text content could be read successfully.</returns>
     private bool TryProcessConfiguration(bool dryRun, out string message)
     {
+        this.configObjects.Clear();
+        
         // Ensure that the main CONFIG table exists and is a valid Lua table:
         if (!this.state.Environment["CONFIG"].TryRead<LuaTable>(out var mainTable))
         {
@@ -59,7 +69,7 @@ public sealed class PluginConfiguration(bool isInternal, LuaState state, PluginT
         ManagedConfiguration.TryProcessConfiguration(x => x.App, x => x.AllowUserToAddProvider, this.Id, settingsTable, dryRun);
 
         //
-        // Configured providers
+        // Configured providers:
         //
         if (!mainTable.TryGetValue("LLM_PROVIDERS", out var providersValue) || !providersValue.TryRead<LuaTable>(out var providersTable))
         {
@@ -94,6 +104,17 @@ public sealed class PluginConfiguration(bool isInternal, LuaState state, PluginT
             // The iterating variable is immutable, so we need to create a local copy:
             var provider = configuredProvider;
 
+            // Store this provider in the config object list:
+            this.configObjects.Add(new()
+            {
+                ConfigPluginId = this.Id,
+                Id = Guid.Parse(provider.Id),
+                Type = PluginConfigurationObjectType.LLM_PROVIDER,
+            });
+
+            if (dryRun)
+                continue;
+            
             var providerIndex = SETTINGS_MANAGER.ConfigurationData.Providers.FindIndex(p => p.Id == provider.Id);
             if (providerIndex > -1)
             {
@@ -109,8 +130,65 @@ public sealed class PluginConfiguration(bool isInternal, LuaState state, PluginT
                 SETTINGS_MANAGER.ConfigurationData.Providers.Add(provider);
             }
         }
+        
         #pragma warning restore MWAIS0001
         
+        //
+        // Configured chat templates:
+        //
+        if (mainTable.TryGetValue("CHAT_TEMPLATES", out var templatesValue) && templatesValue.TryRead<LuaTable>(out var templatesTable))
+        {
+            var numberTemplates = templatesTable.ArrayLength;
+            var configuredTemplates = new List<ChatTemplate>(numberTemplates);
+            for (var i = 1; i <= numberTemplates; i++)
+            {
+                var templateLuaTableValue = templatesTable[i];
+                if (!templateLuaTableValue.TryRead<LuaTable>(out var templateLuaTable))
+                {
+                    LOGGER.LogWarning($"The CHAT_TEMPLATES table at index {i} is not a valid table.");
+                    continue;
+                }
+                
+                if(this.TryReadChatTemplateTable(i, templateLuaTable, out var template) && template != ChatTemplate.NO_CHAT_TEMPLATE)
+                    configuredTemplates.Add(template);
+                else
+                    LOGGER.LogWarning($"The CHAT_TEMPLATES table at index {i} does not contain a valid chat template configuration.");
+            }
+            
+            // Apply configured chat templates to the system settings:
+            foreach (var configuredTemplate in configuredTemplates)
+            {
+                // The iterating variable is immutable, so we need to create a local copy:
+                var template = configuredTemplate;
+                
+                // Store this provider in the config object list:
+                this.configObjects.Add(new()
+                {
+                    ConfigPluginId = this.Id,
+                    Id = Guid.Parse(template.Id),
+                    Type = PluginConfigurationObjectType.CHAT_TEMPLATE,
+                });
+
+                if (dryRun)
+                    continue;
+                
+                var tplIndex = SETTINGS_MANAGER.ConfigurationData.ChatTemplates.FindIndex(t => t.Id == template.Id);
+                if (tplIndex > -1)
+                {
+                    // Case: The template already exists, we update it:
+                    var existingTemplate = SETTINGS_MANAGER.ConfigurationData.ChatTemplates[tplIndex];
+                    template = template with { Num = existingTemplate.Num };
+                    SETTINGS_MANAGER.ConfigurationData.ChatTemplates[tplIndex] = template;
+                }
+                else
+                {
+                    // Case: The template does not exist, we add it:
+                    template = template with { Num = SETTINGS_MANAGER.ConfigurationData.NextChatTemplateNum++ };
+                    SETTINGS_MANAGER.ConfigurationData.ChatTemplates.Add(template);
+                }
+            }
+        }
+        
         return true;
     }
     
@@ -194,4 +272,96 @@ public sealed class PluginConfiguration(bool isInternal, LuaState state, PluginT
         model = new(id, displayName);
         return true;
     }
+
+    private bool TryReadChatTemplateTable(int idx, LuaTable table, out ChatTemplate template)
+    {
+        template = ChatTemplate.NO_CHAT_TEMPLATE;
+        if (!table.TryGetValue("Id", out var idValue) || !idValue.TryRead<string>(out var idText) || !Guid.TryParse(idText, out var id))
+        {
+            LOGGER.LogWarning($"The configured chat template {idx} does not contain a valid ID. The ID must be a valid GUID.");
+            return false;
+        }
+        
+        if (!table.TryGetValue("Name", out var nameValue) || !nameValue.TryRead<string>(out var name))
+        {
+            LOGGER.LogWarning($"The configured chat template {idx} does not contain a valid name.");
+            return false;
+        }
+        
+        if (!table.TryGetValue("SystemPrompt", out var sysPromptValue) || !sysPromptValue.TryRead<string>(out var systemPrompt))
+        {
+            LOGGER.LogWarning($"The configured chat template {idx} does not contain a valid system prompt.");
+            return false;
+        }
+        
+        var predefinedUserPrompt = string.Empty;
+        if (table.TryGetValue("PredefinedUserPrompt", out var preUserValue) && preUserValue.TryRead<string>(out var preUser))
+            predefinedUserPrompt = preUser;
+        
+        var allowProfileUsage = false;
+        if (table.TryGetValue("AllowProfileUsage", out var allowProfileValue) && allowProfileValue.TryRead<bool>(out var allow))
+            allowProfileUsage = allow;
+        
+        template = new()
+        {
+            Num = 0,
+            Id = id.ToString(),
+            Name = name,
+            SystemPrompt = systemPrompt,
+            PredefinedUserPrompt = predefinedUserPrompt,
+            ExampleConversation = ParseExampleConversation(idx, table),
+            AllowProfileUsage = allowProfileUsage,
+            IsEnterpriseConfiguration = true,
+            EnterpriseConfigurationPluginId = this.Id
+        };
+        
+        return true;
+    }
+
+    private static List<ContentBlock> ParseExampleConversation(int idx, LuaTable table)
+    {
+        var exampleConversation = new List<ContentBlock>();
+        if (!table.TryGetValue("ExampleConversation", out var exConvValue) || !exConvValue.TryRead<LuaTable>(out var exConvTable))
+            return exampleConversation;
+        
+        var numBlocks = exConvTable.ArrayLength;
+        for (var j = 1; j <= numBlocks; j++)
+        {
+            var blockValue = exConvTable[j];
+            if (!blockValue.TryRead<LuaTable>(out var blockTable))
+            {
+                LOGGER.LogWarning($"The ExampleConversation entry {j} in chat template {idx} is not a valid table.");
+                continue;
+            }
+            
+            if (!blockTable.TryGetValue("Role", out var roleValue) || !roleValue.TryRead<string>(out var roleText) || !Enum.TryParse<ChatRole>(roleText, true, out var parsedRole))
+            {
+                LOGGER.LogWarning($"The ExampleConversation entry {j} in chat template {idx} does not contain a valid role.");
+                continue;
+            }
+
+            if (!blockTable.TryGetValue("Content", out var contentValue) || !contentValue.TryRead<string>(out var content))
+            {
+                LOGGER.LogWarning($"The ExampleConversation entry {j} in chat template {idx} does not contain a valid content message.");
+                continue;
+            }
+                
+            if (string.IsNullOrWhiteSpace(content))
+            {
+                LOGGER.LogWarning($"The ExampleConversation entry {j} in chat template {idx} contains an empty content message.");
+                continue;
+            }
+                
+            exampleConversation.Add(new ContentBlock
+            {
+                Time = DateTimeOffset.UtcNow,
+                Role = parsedRole,
+                Content = new ContentText { Text = content },
+                ContentType = ContentType.TEXT,
+                HideFromUser = true,
+            });
+        }
+
+        return exampleConversation;
+    }
 }