AI-Studio/app/MindWork AI Studio/Settings/Provider.cs

using System.Text.Json.Serialization;

using AIStudio.Provider;
using AIStudio.Provider.HuggingFace;
using AIStudio.Tools.PluginSystem;

using Lua;

using Host = AIStudio.Provider.SelfHosted.Host;

namespace AIStudio.Settings;

/// <summary>
/// Data model for configured providers.
/// </summary>
/// <param name="Num">The provider's number.</param>
/// <param name="Id">The provider's ID.</param>
/// <param name="InstanceName">The provider's instance name. Useful for multiple instances of the same provider, e.g., to distinguish between different OpenAI API keys.</param>
/// <param name="UsedLLMProvider">The provider used.</param>
/// <param name="IsSelfHosted">Whether the provider is self-hosted.</param>
/// <param name="Hostname">The hostname of the provider. Useful for self-hosted providers.</param>
/// <param name="Model">The LLM model to use for chat.</param>
public sealed record Provider(
    uint Num,
    string Id,
    string InstanceName,
    LLMProviders UsedLLMProvider,
    Model Model,
    bool IsSelfHosted = false,
    bool IsEnterpriseConfiguration = false,
    Guid EnterpriseConfigurationPluginId = default,
    string Hostname = "http://localhost:1234",
    Host Host = Host.NONE,
    HFInferenceProvider HFInferenceProvider = HFInferenceProvider.NONE,
    string AdditionalJsonApiParameters = "",
    string TokenizerPath = "") : ConfigurationBaseObject, ISecretId
{
    private static readonly ILogger<Provider> LOGGER = Program.LOGGER_FACTORY.CreateLogger<Provider>();
    
    public static readonly Provider NONE = new();

    public Provider() : this(
        0,
        Guid.Empty.ToString(),
        string.Empty,
        LLMProviders.NONE,
        default, 
        false,
        false,
        Guid.Empty)
    {
    }
    
    #region Overrides of ValueType

    /// <summary>
    /// Returns a string that represents the current provider in a human-readable format.
    /// We use this to display the provider in the chat UI.
    /// </summary>
    /// <returns>A string that represents the current provider in a human-readable format.</returns>
    public override string ToString()
    {
        if(this.IsSelfHosted)
            return $"{this.InstanceName} ({this.UsedLLMProvider.ToName()}, {this.Host}, {this.Hostname}, {this.Model})";

        return $"{this.InstanceName} ({this.UsedLLMProvider.ToName()}, {this.Model})";
    }

    #endregion
    
    #region Implementation of ISecretId
    
    /// <inheritdoc />
    [JsonIgnore]
    public string SecretId => this.IsEnterpriseConfiguration ? $"{ISecretId.ENTERPRISE_KEY_PREFIX}::{this.UsedLLMProvider.ToName()}" : this.UsedLLMProvider.ToName();
    
    /// <inheritdoc />
    [JsonIgnore]
    public string SecretName => this.InstanceName;
    
    #endregion

    #region Implementation of IConfigurationObject

    public override string Name
    {
        get => this.InstanceName;
        init => this.InstanceName = value;
    }

    #endregion
    
    public static bool TryParseProviderTable(int idx, LuaTable table, Guid configPluginId, out ConfigurationBaseObject provider)
    {
        provider = NONE;
        if (!table.TryGetValue("Id", out var idValue) || !idValue.TryRead<string>(out var idText) || !Guid.TryParse(idText, out var id))
        {
            LOGGER.LogWarning($"The configured provider {idx} does not contain a valid ID. The ID must be a valid GUID. (Plugin ID: {configPluginId})");
            return false;
        }

        if (!table.TryGetValue("InstanceName", out var instanceNameValue) || !instanceNameValue.TryRead<string>(out var instanceName))
        {
            LOGGER.LogWarning($"The configured provider {idx} does not contain a valid instance name. (Plugin ID: {configPluginId})");
            return false;
        }

        if (!table.TryGetValue("UsedLLMProvider", out var usedLLMProviderValue) || !usedLLMProviderValue.TryRead<string>(out var usedLLMProviderText) || !Enum.TryParse<LLMProviders>(usedLLMProviderText, true, out var usedLLMProvider))
        {
            LOGGER.LogWarning($"The configured provider {idx} does not contain a valid LLM provider enum value. (Plugin ID: {configPluginId})");
            return false;
        }
        
        if (!table.TryGetValue("Host", out var hostValue) || !hostValue.TryRead<string>(out var hostText) || !Enum.TryParse<Host>(hostText, true, out var host))
        {
            LOGGER.LogWarning($"The configured provider {idx} does not contain a valid host enum value. (Plugin ID: {configPluginId})");
            return false;
        }
        
        if (!table.TryGetValue("Hostname", out var hostnameValue) || !hostnameValue.TryRead<string>(out var hostname))
        {
            LOGGER.LogWarning($"The configured provider {idx} does not contain a valid hostname. (Plugin ID: {configPluginId})");
            return false;
        }

        var hfInferenceProvider = HFInferenceProvider.NONE;
        if (table.TryGetValue("HFInferenceProvider", out var hfInferenceProviderValue) && hfInferenceProviderValue.TryRead<string>(out var hfInferenceProviderText))
        {
            if (!Enum.TryParse(hfInferenceProviderText, true, out hfInferenceProvider))
            {
                LOGGER.LogWarning($"The configured provider {idx} does not contain a valid Hugging Face inference provider enum value. (Plugin ID: {configPluginId})");
                hfInferenceProvider = HFInferenceProvider.NONE;
            }
        }
        
        if (!table.TryGetValue("Model", out var modelValue) || !modelValue.TryRead<LuaTable>(out var modelTable))
        {
            LOGGER.LogWarning($"The configured provider {idx} does not contain a valid model table. (Plugin ID: {configPluginId})");
            return false;
        }
        
        if (!TryReadModelTable(idx, modelTable, configPluginId, out var model))
        {
            LOGGER.LogWarning($"The configured provider {idx} does not contain a valid model configuration. (Plugin ID: {configPluginId})");
            return false;
        }
        
        if (!table.TryGetValue("AdditionalJsonApiParameters", out var additionalJsonApiParametersValue) || !additionalJsonApiParametersValue.TryRead<string>(out var additionalJsonApiParameters))
        {
            // In this case, no reason exists to reject this provider, though.
            LOGGER.LogWarning($"The configured provider {idx} does not contain valid additional JSON API parameters. (Plugin ID: {configPluginId})");
            additionalJsonApiParameters = string.Empty;
        }

        var tokenizerPath = string.Empty;
        if (table.TryGetValue("TokenizerPath", out var tokenizerPathValue) && !tokenizerPathValue.TryRead<string>(out tokenizerPath))
        {
            LOGGER.LogWarning($"The configured provider {idx} does not contain a valid tokenizer path. (Plugin ID: {configPluginId})");
            tokenizerPath = string.Empty;
        }

        provider = new Provider
        {
            Num = 0, // will be set later by the PluginConfigurationObject
            Id = id.ToString(),
            InstanceName = instanceName,
            UsedLLMProvider = usedLLMProvider,
            Model = model,
            IsSelfHosted = usedLLMProvider is LLMProviders.SELF_HOSTED,
            IsEnterpriseConfiguration = true,
            EnterpriseConfigurationPluginId = configPluginId,
            Hostname = hostname,
            Host = host,
            HFInferenceProvider = hfInferenceProvider,
            AdditionalJsonApiParameters = additionalJsonApiParameters,
            TokenizerPath = tokenizerPath,
        };

        // Handle encrypted API key if present:
        if (table.TryGetValue("APIKey", out var apiKeyValue) && apiKeyValue.TryRead<string>(out var apiKeyText) && !string.IsNullOrWhiteSpace(apiKeyText))
        {
            if (!EnterpriseEncryption.IsEncrypted(apiKeyText))
                LOGGER.LogWarning($"The configured provider {idx} contains a plaintext API key. Only encrypted API keys (starting with 'ENC:v1:') are supported. (Plugin ID: {configPluginId})");
            else
            {
                var encryption = PluginFactory.EnterpriseEncryption;
                if (encryption?.IsAvailable == true)
                {
                    if (encryption.TryDecrypt(apiKeyText, out var decryptedApiKey))
                    {
                        // Queue the API key for storage in the OS keyring:
                        PendingEnterpriseApiKeys.Add(new(
                            $"{ISecretId.ENTERPRISE_KEY_PREFIX}::{usedLLMProvider.ToName()}",
                            instanceName,
                            decryptedApiKey,
                            SecretStoreType.LLM_PROVIDER));
                        LOGGER.LogDebug($"Successfully decrypted API key for provider {idx}. It will be stored in the OS keyring. (Plugin ID: {configPluginId})");
                    }
                    else
                        LOGGER.LogWarning($"Failed to decrypt API key for provider {idx}. The encryption secret may be incorrect. (Plugin ID: {configPluginId})");
                }
                else
                    LOGGER.LogWarning($"The configured provider {idx} contains an encrypted API key, but no encryption secret is configured. (Plugin ID: {configPluginId})");
            }
        }

        return true;
    }

    private static bool TryReadModelTable(int idx, LuaTable table, Guid configPluginId, out Model model)
    {
        model = default;
        if (!table.TryGetValue("Id", out var idValue) || !idValue.TryRead<string>(out var id))
        {
            LOGGER.LogWarning($"The configured provider {idx} does not contain a valid model ID. (Plugin ID: {configPluginId})");
            return false;
        }
        
        if (!table.TryGetValue("DisplayName", out var displayNameValue) || !displayNameValue.TryRead<string>(out var displayName))
        {
            LOGGER.LogWarning($"The configured provider {idx} does not contain a valid model display name. (Plugin ID: {configPluginId})");
            return false;
        }
        
        model = new(id, displayName);
        return true;
    }

    /// <summary>
    /// Exports the provider configuration as a Lua configuration section.
    /// </summary>
    /// <param name="encryptedApiKey">Optional encrypted API key to include in the export.</param>
    /// <returns>A Lua configuration section string.</returns>
    public string ExportAsConfigurationSection(string? encryptedApiKey = null)
    {
        var lines = new List<string>
        {
            "CONFIG[\"LLM_PROVIDERS\"][#CONFIG[\"LLM_PROVIDERS\"]+1] = {",
            $"    [\"Id\"] = \"{Guid.NewGuid()}\",",
            $"    [\"InstanceName\"] = \"{LuaTools.EscapeLuaString(this.InstanceName)}\",",
            $"    [\"UsedLLMProvider\"] = \"{this.UsedLLMProvider}\",",
        };

        if (!string.IsNullOrWhiteSpace(this.TokenizerPath))
        {
            lines.Add(string.Empty);
            lines.Add("    -- The tokenizer path shown is local to this model. To use it with the plugin:");
            lines.Add("        -- 1. Copy the tokenizer into the zip.");
            lines.Add("        -- 2. Update the path in the plugin file to be relative to the zip's root.");
            lines.Add($"    [\"TokenizerPath\"] = \"{LuaTools.EscapeLuaString(this.TokenizerPath)}\",");
        }

        lines.Add(string.Empty);
        lines.Add($"    [\"Host\"] = \"{this.Host}\",");
        lines.Add($"    [\"Hostname\"] = \"{LuaTools.EscapeLuaString(this.Hostname)}\",");

        if (this.HFInferenceProvider is not HFInferenceProvider.NONE)
            lines.Add($"    [\"HFInferenceProvider\"] = \"{this.HFInferenceProvider}\",");

        if (!string.IsNullOrWhiteSpace(encryptedApiKey))
            lines.Add($"    [\"APIKey\"] = \"{LuaTools.EscapeLuaString(encryptedApiKey)}\",");

        lines.Add($"    [\"AdditionalJsonApiParameters\"] = \"{LuaTools.EscapeLuaString(this.AdditionalJsonApiParameters)}\",");
        lines.Add("    [\"Model\"] = {");
        lines.Add($"        [\"Id\"] = \"{LuaTools.EscapeLuaString(this.Model.Id)}\",");
        lines.Add($"        [\"DisplayName\"] = \"{LuaTools.EscapeLuaString(this.Model.DisplayName ?? this.Model.Id)}\",");
        lines.Add("    },");
        lines.Add("}");

        return string.Join(Environment.NewLine, lines);
    }
}