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;
+    }
 }

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

@@ -0,0 +1,23 @@
+namespace AIStudio.Tools.PluginSystem;
+
+/// <summary>
+/// Represents metadata for a configuration object from a configuration plugin. These are
+/// complex objects such as configured LLM providers, chat templates, etc.
+/// </summary>
+public sealed record PluginConfigurationObject
+{
+    /// <summary>
+    /// The id of the configuration plugin to which this configuration object belongs.
+    /// </summary>
+    public required Guid ConfigPluginId { get; init; } = Guid.NewGuid();
+    
+    /// <summary>
+    /// The id of the configuration object, e.g., the id of a chat template.
+    /// </summary>
+    public required Guid Id { get; init; } = Guid.NewGuid();
+
+    /// <summary>
+    /// The type of the configuration object.
+    /// </summary>
+    public required PluginConfigurationObjectType Type { get; init; } = PluginConfigurationObjectType.NONE;
+}

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

@@ -0,0 +1,13 @@
+namespace AIStudio.Tools.PluginSystem;
+
+public enum PluginConfigurationObjectType
+{
+    NONE,
+    UNKNOWN,
+    
+    PROFILE,
+    DATA_SOURCE,
+    LLM_PROVIDER,
+    CHAT_TEMPLATE,
+    EMBEDDING_PROVIDER,
+}

app/MindWork AI Studio/Tools/PluginSystem/PluginFactory.Loading.cs

@@ -40,6 +40,8 @@ public static partial class PluginFactory
         if (!await PLUGIN_LOAD_SEMAPHORE.WaitAsync(0, cancellationToken))
             return;
 
+        var configObjectList = new List<PluginConfigurationObject>();
+        
         try
         {
             LOG.LogInformation("Start loading plugins.");
@@ -112,7 +114,8 @@ public static partial class PluginFactory
             }
         
             // Start or restart all plugins:
-            await RestartAllPlugins(cancellationToken);
+            var configObjects = await RestartAllPlugins(cancellationToken);
+            configObjectList.AddRange(configObjects);
         }
         finally
         {
@@ -149,9 +152,51 @@ public static partial class PluginFactory
                 SETTINGS_MANAGER.ConfigurationData.Providers.Remove(configuredProvider);
                 wasConfigurationChanged = true;
             }
+            
+            if(!configObjectList.Any(configObject =>
+                configObject.Type is PluginConfigurationObjectType.LLM_PROVIDER &&
+                configObject.ConfigPluginId == providerSourcePluginId &&
+                configObject.Id.ToString() == configuredProvider.Id))
+            {
+                LOG.LogWarning($"The configured LLM provider '{configuredProvider.InstanceName}' (id={configuredProvider.Id}) is not present in the configuration plugin anymore. Removing the provider from the settings.");
+                SETTINGS_MANAGER.ConfigurationData.Providers.Remove(configuredProvider);
+                wasConfigurationChanged = true;
+            }
         }
         #pragma warning restore MWAIS0001
+        
+        //
+        // Check chat templates:
+        //
+        var configuredTemplates = SETTINGS_MANAGER.ConfigurationData.ChatTemplates.ToList();
+        foreach (var configuredTemplate in configuredTemplates)
+        {
+            if(!configuredTemplate.IsEnterpriseConfiguration)
+                continue;
 
+            var templateSourcePluginId = configuredTemplate.EnterpriseConfigurationPluginId;
+            if(templateSourcePluginId == Guid.Empty)
+                continue;
+            
+            var templateSourcePlugin = AVAILABLE_PLUGINS.FirstOrDefault(plugin => plugin.Id == templateSourcePluginId);
+            if(templateSourcePlugin is null)
+            {
+                LOG.LogWarning($"The configured chat template '{configuredTemplate.Name}' (id={configuredTemplate.Id}) is based on a plugin that is not available anymore. Removing the chat template from the settings.");
+                SETTINGS_MANAGER.ConfigurationData.ChatTemplates.Remove(configuredTemplate);
+                wasConfigurationChanged = true;
+            }
+            
+            if(!configObjectList.Any(configObject =>
+                configObject.Type is PluginConfigurationObjectType.CHAT_TEMPLATE &&
+                configObject.ConfigPluginId == templateSourcePluginId &&
+                configObject.Id.ToString() == configuredTemplate.Id))
+            {
+                LOG.LogWarning($"The configured chat template '{configuredTemplate.Name}' (id={configuredTemplate.Id}) is not present in the configuration plugin anymore. Removing the chat template from the settings.");
+                SETTINGS_MANAGER.ConfigurationData.ChatTemplates.Remove(configuredTemplate);
+                wasConfigurationChanged = true;
+            }
+        }
+        
         //
         // ==========================================================
         // Check all possible settings:

app/MindWork AI Studio/Tools/PluginSystem/PluginFactory.Starting.cs

@@ -11,9 +11,10 @@ public static partial class PluginFactory
     /// </summary>
     public static IReadOnlyCollection<PluginBase> RunningPlugins => RUNNING_PLUGINS;
     
-    private static async Task RestartAllPlugins(CancellationToken cancellationToken = default)
+    private static async Task<List<PluginConfigurationObject>> RestartAllPlugins(CancellationToken cancellationToken = default)
     {
         LOG.LogInformation("Try to start or restart all plugins.");
+        var configObjects = new List<PluginConfigurationObject>();
         RUNNING_PLUGINS.Clear();
 
         //
@@ -65,7 +66,12 @@ public static partial class PluginFactory
             {
                 if (availablePlugin.IsInternal || SETTINGS_MANAGER.IsPluginEnabled(availablePlugin) || availablePlugin.Type == PluginType.CONFIGURATION)
                     if(await Start(availablePlugin, cancellationToken) is { IsValid: true } plugin)
+                    {
+                        if (plugin is PluginConfiguration configPlugin)
+                            configObjects.AddRange(configPlugin.ConfigObjects);
+                        
                         RUNNING_PLUGINS.Add(plugin);
+                    }
             }
             catch (Exception e)
             {
@@ -75,6 +81,7 @@ public static partial class PluginFactory
         
         // Inform all components that the plugins have been reloaded or started:
         await MessageBus.INSTANCE.SendMessage<bool>(null, Event.PLUGINS_RELOADED);
+        return configObjects;
     }
     
     private static async Task<PluginBase> Start(IAvailablePlugin meta, CancellationToken cancellationToken = default)