Tool.cs

using System;
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Reflection;
using System.Threading.Tasks;
using Waher.Networking.HTTP.JsonRpc;
using Waher.Networking.HTTP.JsonRpc.MetaData;
using Waher.Networking.HTTP.Mcp.Model.Attributes;
using Waher.Networking.HTTP.Mcp.Model.ContentBlocks;
using Waher.Persistence;
using Waher.Runtime.Collections;
using Waher.Runtime.Inventory;
using Waher.Script;
using Waher.Script.Model;
 
namespace Waher.Networking.HTTP.Mcp.Model.Server
{
    public class Tool : ProtectedMethod
    {
        private const string McpToolResultTitle = "Result";
        private const string McpToolResultDescription = "Result returned after executing the tool.";
 
        private Icons? icons = null;
 
        public Tool(MethodInfo Method, string Title, string Description,
            string IconsMethod, bool CanModifyEnvironment, bool CanDestroyEnvironment,
            bool Idempotent, bool OpenWorldAccess,
            params KeyValuePair<string, object>[] MetaData)
            : base(Method, false)
        {
            this.Title = Title;
            this.Description = Description;
            this.IconsMethod = IconsMethod;
            this.CanModifyEnvironment = CanModifyEnvironment;
            this.CanDestroyEnvironment = CanDestroyEnvironment;
            this.Idempotent = Idempotent;
            this.OpenWorldAccess = OpenWorldAccess;
            this.MetaData = MetaData;
            this.HasStructuredReturnValue = this.HasReturnValue;
 
            Type ReturnType = this.Method.ReturnType;
 
            while (this.HasStructuredReturnValue)
            {
                if (HttpMcpServerResource.TryGetEncodingContentBlock(ReturnType,
                    out IContentBlock ContentBlock))
                {
                    this.HasStructuredReturnValue = ContentBlock.IsStructuredContent;
                    break;
                }
                else if (typeof(IContentBlock).IsAssignableFrom(Method.ReturnType))
                {
                    ContentBlock = (ContentBlock)Types.Instantiate(ReturnType);
                    if (!ContentBlock.IsStructuredContent)
                        this.HasStructuredReturnValue = false;
                    break;
                }
                else if (ReturnType.IsGenericType &&
                    ReturnType.GetGenericTypeDefinition() == typeof(Task<>))
                {
                    Type[] TypeArguments = ReturnType.GetGenericArguments();
                    if (TypeArguments.Length == 1)
                        ReturnType = TypeArguments[0];
                    else
                        break;
                }
                else
                    break;
            }
        }
 
        public string Title { get; }
 
        public string Description { get; }
 
        public string IconsMethod { get; }
 
        public bool CanModifyEnvironment { get; }
 
        public bool CanDestroyEnvironment { get; }
 
        public bool Idempotent { get; }
 
        public bool OpenWorldAccess { get; }
 
        public KeyValuePair<string, object>[] MetaData { get; }
 
        public bool HasStructuredReturnValue { get; }
 
        public async Task<Dictionary<string, object>> ToJson(HttpMcpServerResource Resource)
        {
            this.icons ??= await GetIcons(Resource, this.IconsMethod);
 
            Dictionary<string, object> Annotations = new Dictionary<string, object>()
            {
                { "readOnlyHint", this.CanModifyEnvironment },
                { "destructiveHint", this.CanDestroyEnvironment },
                { "idempotentHint", this.Idempotent },
                { "openWorldHint", this.OpenWorldAccess }
            };
            Dictionary<string, object> Result = new Dictionary<string, object>()
            {
                { "name", this.Method.Name },
                { "execution", new Dictionary<string,object>()
                    {
                        { "taskSupport", "optional" }
                    }
                },
                { "inputSchema", GenerateSchema(this.Method) },
                { "annotations", Annotations }
            };
 
            if (!string.IsNullOrEmpty(this.Title))
                Result.Add("title", this.Title);
 
            if (!string.IsNullOrEmpty(this.Description))
                Result.Add("description", this.Description);
 
            if (!this.icons.Empty)
                Result.Add("icons", this.icons.ToJson());
 
            if (this.HasStructuredReturnValue)
            {
                McpParameterAttribute ReturnInfo = this.Method.ReturnParameter.GetCustomAttribute<McpParameterAttribute>(true);
                IEnumerable<McpEnumValueAttribute>? EnumValues = this.Method.ReturnType.IsEnum ?
                    this.Method.ReturnParameter.GetCustomAttributes<McpEnumValueAttribute>(true) : null;
 
                Result.Add("outputSchema", GenerateOutputSchema(this.Method.ReturnType,
                    ReturnInfo, EnumValues));
            }
 
            if ((this.MetaData?.Length ?? 0) > 0)
            {
                Dictionary<string, object> MetaData = new Dictionary<string, object>();
 
                foreach (KeyValuePair<string, object> P in this.MetaData!)
                    MetaData[P.Key] = P.Value;
 
                Result["_meta"] = MetaData;
            }
 
            return Result;
        }
 
        internal static async Task<Icons> GetIcons(HttpMcpServerResource Resource, string IconsMethod)
        {
            Icons Icons;
 
            if (string.IsNullOrEmpty(IconsMethod))
                Icons = new Icons();
            else
            {
                MethodInfo? MI = Resource.GetType().GetMethod(IconsMethod,
                    BindingFlags.Static | BindingFlags.Instance |
                    BindingFlags.Public | BindingFlags.NonPublic);
 
                if (MI is null)
                    Icons = new Icons();
                else
                {
                    object? Obj = await ScriptNode.WaitPossibleTask(MI.Invoke(Resource, null));
 
                    if (Obj is Icons Typed)
                        Icons = Typed;
                    else if (Obj is Icon[] IconArray)
                        Icons = new Icons(IconArray);
                    else if (Obj is Icon SingleIcon)
                        Icons = new Icons(SingleIcon);
                    else if (Obj is null)
                        Icons = new Icons();
                    else
                    {
                        throw new ArgumentException("Method " + IconsMethod +
                            "returned an invalid type: " + Obj.GetType().FullName,
                            nameof(IconsMethod));
                    }
                }
            }
 
            if (Icons.Empty)
                Icons = Resource.Icons;
 
            return Icons;
        }
 
        internal static Dictionary<string, object> GenerateSchema(MethodInfo Method)
        {
            ParameterInfo[] Parameters = Method.GetParameters();
            Dictionary<string, object> Result = new Dictionary<string, object>()
            {
                { "type", "object" }
            };
 
            if (Parameters.Length == 0)
                Result["additionalProperties"] = false;
            else
            {
                Dictionary<string, object> Properties = new Dictionary<string, object>();
                ChunkedList<string> Required = new ChunkedList<string>();
 
                foreach (ParameterInfo Parameter in Parameters)
                {
                    Type ParameterType = Parameter.ParameterType;
 
                    if (ParameterType == typeof(HttpRequest) ||
                        ParameterType == typeof(HttpResponse))
                    {
                        continue;
                    }
 
                    if (!Parameter.IsOptional && !Parameter.HasDefaultValue)
                        Required.Add(Parameter.Name);
 
                    McpParameterAttribute ParameterInfo = Parameter.GetCustomAttribute<McpParameterAttribute>(true);
                    IEnumerable<McpEnumValueAttribute>? EnumValues = ParameterType.IsEnum ?
                        Parameter.GetCustomAttributes<McpEnumValueAttribute>(true) : null;
 
                    Properties[Parameter.Name] = GenerateSchema(ParameterType,
                        Parameter.HasDefaultValue, Parameter.DefaultValue, ParameterInfo,
                        EnumValues);
                }
 
                Result["properties"] = Properties;
                Result["required"] = Required.ToArray();
            }
 
            return Result;
        }
 
        internal static Dictionary<string, object> GenerateOutputSchema(Type ReturnType,
            McpParameterAttribute? ParameterInfo, IEnumerable<McpEnumValueAttribute>? EnumValues)
        {
            Dictionary<string, object> Result = new Dictionary<string, object>()
            {
                { "type", "object" },
                { "result", GenerateSchema(ReturnType, false, null, ParameterInfo, EnumValues) },
                { "title", McpToolResultTitle },
                { "description", McpToolResultDescription },
            };
 
            if (Expression.IsVoid(ReturnType))
                Result["required"] = Array.Empty<string>();
            else
                Result["required"] = new string[] { "result" };
 
            return Result;
        }
 
        internal static object GenerateSchema(Type T, bool HasDefault, object? Default,
            McpParameterAttribute? ParameterInfo, IEnumerable<McpEnumValueAttribute>? EnumValues)
        {
            Dictionary<string, object?> Result = new Dictionary<string, object?>();
            bool EmitDefault = HasDefault;
 
            if (T.IsEnum)
            {
                ChunkedList<Dictionary<string, object>>? EnumValuesList;
 
                if (EnumValues is null)
                    EnumValuesList = null;
                else
                {
                    EnumValuesList = new ChunkedList<Dictionary<string, object>>();
 
                    foreach (McpEnumValueAttribute EnumValue in EnumValues)
                    {
                        EnumValuesList.Add(new Dictionary<string, object>()
                        {
                            { "const", EnumValue.Value.ToString() },
                            { "title", EnumValue.Title ?? EnumValue.Value.ToString() }
                        });
                    }
                }
 
                if (Attribute.IsDefined(T, typeof(FlagsAttribute)))
                {
                    Result["type"] = "array";
 
                    if (EnumValuesList is null)
                    {
                        Result["items"] = new Dictionary<string, object>()
                        {
                            { "type", "string" },
                            { "enum", Enum.GetNames(T) }
                        };
                    }
                    else
                    {
                        Result["items"] = new Dictionary<string, object>()
                        {
                            { "anyOf", EnumValuesList.ToArray() }
                        };
                    }
                }
                else
                {
                    Result["type"] = "string";
 
                    if (EnumValuesList is null)
                        Result["enum"] = Enum.GetNames(T);
                    else
                        Result["oneOf"] = EnumValuesList.ToArray();
                }
            }
            else
            {
                switch (Type.GetTypeCode(T))
                {
                    case TypeCode.Empty:
                        Result["type"] = "null";
                        break;
 
                    case TypeCode.Object:
                        if (T == typeof(CaseInsensitiveString))
                            Result["type"] = "string";
                        else if (T == typeof(Uri))
                        {
                            Result["type"] = "string";
                            Result["format"] = "uri";
                        }
                        else if (T.IsArray)
                        {
                            Result["type"] = "array";
                            Result["items"] = GenerateSchema(T.GetElementType()!, false, null, null, null);
                        }
                        else if (T == typeof(Dictionary<string, object>))
                        {
                            EmitDefault = false;
                            Result["type"] = "object";
                            //Result["additionalProperties"] = true;// new Dictionary<string, object>();
                        }
                        else
                        {
                            if (T.IsGenericType)
                            {
                                Type GenericType = T.GetGenericTypeDefinition();
 
                                if (GenericType == typeof(Nullable<>) ||
                                    GenericType == typeof(Task<>))
                                {
                                    return GenerateSchema(T.GenericTypeArguments[0], true, Default,
                                        ParameterInfo, EnumValues);
                                }
                            }
 
                            Dictionary<string, object> Properties = new Dictionary<string, object>();
 
                            EmitDefault = false;
                            Result["type"] = "object";
                            Result["properties"] = Properties;
 
                            foreach (FieldInfo FI in T.GetFields(BindingFlags.Public | BindingFlags.Instance))
                            {
                                Type FieldType = FI.FieldType;
                                McpParameterAttribute FieldInfo = FI.GetCustomAttribute<McpParameterAttribute>(true);
                                IEnumerable<McpEnumValueAttribute>? EnumValues2 = FieldType.IsEnum ?
                                    FI.GetCustomAttributes<McpEnumValueAttribute>(true) : null;
 
                                object? FieldDefault = Default is null ? null : FI.GetValue(Default);
                                Properties[FI.Name] = GenerateSchema(FieldType, !(Default is null), 
                                    FieldDefault, FieldInfo, EnumValues2);
                            }
 
                            foreach (PropertyInfo PI in T.GetProperties(BindingFlags.Public | BindingFlags.Instance))
                            {
                                Type PropertyType = PI.PropertyType;
                                McpParameterAttribute PropertyInfo = PI.GetCustomAttribute<McpParameterAttribute>(true);
                                IEnumerable<McpEnumValueAttribute>? EnumValues2 = PropertyType.IsEnum ?
                                    PI.GetCustomAttributes<McpEnumValueAttribute>(true) : null;
 
                                object? PropertyDefault = Default is null ? null : PI.GetValue(Default);
                                Properties[PI.Name] = GenerateSchema(PropertyType, !(Default is null), 
                                    PropertyDefault, PropertyInfo, EnumValues2);
                            }
                        }
                        break;
 
                    case TypeCode.DBNull:
                        Result["type"] = "null";
                        break;
 
                    case TypeCode.Boolean:
                        Result["type"] = "boolean";
                        break;
 
                    case TypeCode.Char:
                        Result["type"] = "string";
                        break;
 
                    case TypeCode.SByte:
                        Result["type"] = "integer";
                        Result["minimum"] = sbyte.MinValue;
                        Result["maximum"] = sbyte.MaxValue;
                        break;
 
                    case TypeCode.Byte:
                        Result["type"] = "integer";
                        Result["minimum"] = byte.MinValue;
                        Result["maximum"] = byte.MaxValue;
                        break;
 
                    case TypeCode.Int16:
                        Result["type"] = "integer";
                        Result["minimum"] = short.MinValue;
                        Result["maximum"] = short.MaxValue;
                        break;
 
                    case TypeCode.UInt16:
                        Result["type"] = "integer";
                        Result["minimum"] = ushort.MinValue;
                        Result["maximum"] = ushort.MaxValue;
                        break;
 
                    case TypeCode.Int32:
                        Result["type"] = "integer";
                        Result["minimum"] = int.MinValue;
                        Result["maximum"] = int.MaxValue;
                        break;
 
                    case TypeCode.UInt32:
                        Result["type"] = "integer";
                        Result["minimum"] = uint.MinValue;
                        Result["maximum"] = uint.MaxValue;
                        break;
 
                    case TypeCode.Int64:
                        Result["type"] = "integer";
                        Result["minimum"] = long.MinValue;
                        Result["maximum"] = long.MaxValue;
                        break;
 
                    case TypeCode.UInt64:
                        Result["type"] = "integer";
                        Result["minimum"] = ulong.MinValue;
                        Result["maximum"] = ulong.MaxValue;
                        break;
 
                    case TypeCode.Single:
                    case TypeCode.Double:
                    case TypeCode.Decimal:
                        Result["type"] = "number";
                        break;
 
                    case TypeCode.DateTime:
                        {
                            Result["type"] = "string";
                            Result["format"] = "date-time";
                        }
                        break;
 
                    case TypeCode.String:
                        Result["type"] = "string";
                        break;
                }
            }
 
            if (EmitDefault)
                Result["default"] = Default;
 
            ParameterInfo?.Annotate(Result);
 
            return Result;
        }
 
        public bool TryBuildRequest(object? Id, Dictionary<string, object?> Parameters,
            HttpRequest Request, HttpResponse Response,
            Dictionary<string, object?>? MetaData,
            [NotNullWhen(false)] out string? Reason,
            [NotNullWhen(true)] out object?[]? Arguments)
        {
            if (!this.TryBuildRequest(Id, Parameters, MetaData, out Reason, out Arguments))
                return false;
 
            if (this.RequestArgument.HasValue)
                Arguments[this.RequestArgument.Value] = Request;
 
            if (this.ResponseArgument.HasValue)
                Arguments[this.ResponseArgument.Value] = Response;
 
            if (this.IdArgument.HasValue)
                Arguments[this.IdArgument.Value] = Id;
 
            return true;
        }
 
    }
}