Add 3D map UX improvements, XNCF auto-attach for agents, and Create Agent from PromptCode

src/Basic/Senparc.Ncf.XncfBase.Tests/Functions/FunctionHelperTests.cs

@@ -5,8 +5,10 @@
 using Senparc.Ncf.XncfBase.FunctionRenders;
 using Senparc.Ncf.XncfBase.Tests;
 using System;
+using System.Collections.Generic;
 using System.ComponentModel.DataAnnotations;
 using System.Linq;
+using System.Text.Json.Serialization;
 using System.Threading.Tasks;
 
 namespace Senparc.Ncf.XncfBase.Functions.Tests
@@ -36,14 +38,41 @@ public override async Task LoadData(IServiceProvider serviceProvider)
             }
         }
 
-        [FunctionRender("设置参数", "设置备份间隔时间、备份文件路径等参数", typeof(Register))]
+                    public class SetSelectionConfigFunctionAppRequest : FunctionAppRequestBase
+                    {
+                        [Required]
+                        [System.ComponentModel.Description("智能体||从下拉中选择，或直接手动输入")]
+                        [FunctionParameterUi(ParameterType.DropDownList, nameof(AgentOptions), Filterable = true, AllowCreate = true)]
+                        public string AgentName { get; set; }
+
+                        [JsonIgnore]
+                        public SelectionList AgentOptions { get; set; } = new SelectionList(SelectionType.DropDownList, new List<SelectionItem>());
+
+                        public override Task LoadData(IServiceProvider serviceProvider)
+                        {
+                            AgentOptions.Items.Add(new SelectionItem("PromptCatalyzer", "PromptCatalyzer", defaultSelected: true));
+                            AgentOptions.Items.Add(new SelectionItem("Scorer", "Scorer"));
+                            return Task.CompletedTask;
+                        }
+                    }
+
+        [FunctionRender("设置参数", "设置备份间隔时间、备份文件路径等参数", typeof(TestModuleRegister))]
         public async Task<StringAppResponse> SetConfig(SetConfigFunctionAppRequest request)
         {
             return await this.GetStringResponseAsync(async (response, logger) =>
             {
                 return request.BackupPath;
             });
         }
+
+        [FunctionRender("设置智能体", "测试简单值 + 下拉元数据", typeof(TestModuleRegister))]
+        public async Task<StringAppResponse> SetSelectionConfig(SetSelectionConfigFunctionAppRequest request)
+        {
+            return await this.GetStringResponseAsync(async (response, logger) =>
+            {
+                return request.AgentName;
+            });
+        }
     }
 
 
@@ -64,5 +93,32 @@ public void GetFunctionParameterInfoAsyncTest()
             Assert.IsTrue(result.Count > 0);
             Console.WriteLine(result.ToJson(true));
         }
+
+        [TestMethod()]
+        public void GetFunctionParameterInfoWithUiAttributeTest()
+        {
+            var functionBag = Senparc.Ncf.XncfBase.Register.FunctionRenderCollection[typeof(TestModuleRegister)].Values
+                .First(z => z.MethodInfo.Name == nameof(TestFunctionAppService.SetSelectionConfig));
+
+            var result = FunctionHelper.GetFunctionParameterInfoAsync(base._serviceProvider, functionBag, true).GetAwaiter().GetResult();
+            var agentName = result.First(z => z.Name == nameof(TestFunctionAppService.SetSelectionConfigFunctionAppRequest.AgentName));
+
+            Assert.AreEqual(ParameterType.DropDownList, agentName.ParameterType);
+            Assert.AreEqual("String", agentName.SystemType);
+            Assert.AreEqual(2, agentName.SelectionList.Items.Count);
+            Assert.IsTrue(agentName.Filterable);
+            Assert.IsTrue(agentName.AllowCreate);
+        }
+
+        [TestMethod()]
+        public void NormalizeLegacySelectionListJsonToStringRequestTest()
+        {
+            var rawJson = "{\"AgentName\":{\"SelectedValues\":[\"PromptCatalyzer\"]}}";
+            var normalizedJson = FunctionRequestParameterNormalizer.NormalizeJson(rawJson, typeof(TestFunctionAppService.SetSelectionConfigFunctionAppRequest));
+
+            var result = Senparc.CO2NET.Helpers.SerializerHelper.GetObject(normalizedJson, typeof(TestFunctionAppService.SetSelectionConfigFunctionAppRequest)) as TestFunctionAppService.SetSelectionConfigFunctionAppRequest;
+
+            Assert.AreEqual("PromptCatalyzer", result.AgentName);
+        }
     }
 }

src/Basic/Senparc.Ncf.XncfBase/FunctionRenders/FunctionRequestParameterNormalizer.cs

@@ -0,0 +1,225 @@
+using Senparc.Ncf.XncfBase.Functions;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using System.Text.Json;
+using System.Text.Json.Nodes;
+
+namespace Senparc.Ncf.XncfBase.FunctionRenders
+{
+    /// <summary>
+    /// Normalizes request payloads so legacy SelectionList JSON and simple string JSON
+    /// can both bind to FunctionRender request types.
+    /// </summary>
+    public static class FunctionRequestParameterNormalizer
+    {
+        public static string NormalizeJson(string rawJson, Type requestType)
+        {
+            if (string.IsNullOrWhiteSpace(rawJson) || requestType == null)
+            {
+                return rawJson;
+            }
+
+            JsonNode rootNode;
+            try
+            {
+                rootNode = JsonNode.Parse(rawJson);
+            }
+            catch
+            {
+                return rawJson;
+            }
+
+            if (rootNode is not JsonObject jsonObject)
+            {
+                return rawJson;
+            }
+
+            var properties = requestType.GetProperties(BindingFlags.Instance | BindingFlags.Public)
+                                        .Where(z => z.CanWrite)
+                                        .ToList();
+
+            foreach (var property in properties)
+            {
+                if (!TryGetJsonProperty(jsonObject, property.Name, out var jsonKey, out var currentNode))
+                {
+                    continue;
+                }
+
+                if (property.PropertyType == typeof(SelectionList))
+                {
+                    jsonObject[jsonKey] = NormalizeSelectionListNode(currentNode);
+                    continue;
+                }
+
+                var uiAttr = property.GetCustomAttribute<FunctionParameterUiAttribute>();
+                jsonObject[jsonKey] = NormalizeSimpleNode(property.PropertyType, currentNode, uiAttr);
+            }
+
+            return jsonObject.ToJsonString(new JsonSerializerOptions
+            {
+                WriteIndented = false
+            });
+        }
+
+        private static JsonNode NormalizeSelectionListNode(JsonNode currentNode)
+        {
+            if (currentNode is JsonObject currentObject && TryGetJsonProperty(currentObject, "SelectedValues", out _, out _))
+            {
+                return currentNode;
+            }
+
+            var values = ExtractValues(currentNode, forMultiple: true);
+            var selectedValues = new JsonArray(values.Select(z => JsonValue.Create(z)).ToArray());
+
+            return new JsonObject
+            {
+                ["SelectedValues"] = selectedValues
+            };
+        }
+
+        private static JsonNode NormalizeSimpleNode(Type targetType, JsonNode currentNode, FunctionParameterUiAttribute uiAttr)
+        {
+            var forMultiple = uiAttr?.ParameterType == ParameterType.CheckBoxList || targetType == typeof(string[]);
+            var values = ExtractValues(currentNode, forMultiple);
+
+            if (targetType == typeof(string[]))
+            {
+                return new JsonArray(values.Select(z => JsonValue.Create(z)).ToArray());
+            }
+
+            if (targetType == typeof(string))
+            {
+                if (currentNode is JsonValue valueNode && TryGetString(valueNode, out var stringValue))
+                {
+                    return JsonValue.Create(stringValue);
+                }
+
+                return JsonValue.Create(forMultiple ? string.Join("\n", values) : values.FirstOrDefault());
+            }
+
+            var firstValue = values.FirstOrDefault();
+            if (firstValue == null)
+            {
+                return null;
+            }
+
+            if (IsNullableType(targetType, typeof(int)) && int.TryParse(firstValue, out var intValue))
+            {
+                return JsonValue.Create(intValue);
+            }
+
+            if (IsNullableType(targetType, typeof(long)) && long.TryParse(firstValue, out var longValue))
+            {
+                return JsonValue.Create(longValue);
+            }
+
+            if (IsNullableType(targetType, typeof(bool)) && bool.TryParse(firstValue, out var boolValue))
+            {
+                return JsonValue.Create(boolValue);
+            }
+
+            return JsonValue.Create(firstValue);
+        }
+
+        private static List<string> ExtractValues(JsonNode currentNode, bool forMultiple)
+        {
+            if (currentNode == null)
+            {
+                return new List<string>();
+            }
+
+            if (currentNode is JsonObject currentObject)
+            {
+                if (TryGetJsonProperty(currentObject, "SelectedValues", out _, out var selectedValuesNode))
+                {
+                    return ExtractValues(selectedValuesNode, true);
+                }
+
+                return new List<string>();
+            }
+
+            if (currentNode is JsonArray currentArray)
+            {
+                return currentArray.SelectMany(z => ExtractValues(z, true))
+                                   .Where(z => !string.IsNullOrWhiteSpace(z))
+                                   .Distinct(StringComparer.Ordinal)
+                                   .ToList();
+            }
+
+            if (currentNode is JsonValue currentValue && TryGetString(currentValue, out var stringValue))
+            {
+                return SplitInput(stringValue, forMultiple);
+            }
+
+            return new List<string>();
+        }
+
+        private static List<string> SplitInput(string input, bool forMultiple)
+        {
+            if (string.IsNullOrWhiteSpace(input))
+            {
+                return new List<string>();
+            }
+
+            if (!forMultiple)
+            {
+                return new List<string> { input.Trim() };
+            }
+
+            return input.Split(new[] { ',', '，', ';', '；', '\n', '\r', '|' }, StringSplitOptions.RemoveEmptyEntries)
+                        .Select(z => z.Trim())
+                        .Where(z => !string.IsNullOrWhiteSpace(z))
+                        .Distinct(StringComparer.Ordinal)
+                        .ToList();
+        }
+
+        private static bool TryGetJsonProperty(JsonObject jsonObject, string propertyName, out string actualKey, out JsonNode currentNode)
+        {
+            actualKey = null;
+            currentNode = null;
+
+            foreach (var item in jsonObject)
+            {
+                if (string.Equals(item.Key, propertyName, StringComparison.OrdinalIgnoreCase))
+                {
+                    actualKey = item.Key;
+                    currentNode = item.Value;
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
+        private static bool TryGetString(JsonValue jsonValue, out string result)
+        {
+            result = null;
+
+            try
+            {
+                result = jsonValue.GetValue<string>();
+                return true;
+            }
+            catch
+            {
+                try
+                {
+                    result = jsonValue.ToString();
+                    return true;
+                }
+                catch
+                {
+                    return false;
+                }
+            }
+        }
+
+        private static bool IsNullableType(Type actualType, Type targetType)
+        {
+            var underlyingType = Nullable.GetUnderlyingType(actualType) ?? actualType;
+            return underlyingType == targetType;
+        }
+    }
+}

src/Basic/Senparc.Ncf.XncfBase/Functions/FunctionHelper.cs

@@ -12,6 +12,7 @@
 using System.IO;
 using System.Linq;
 using System.Reflection;
+using System.Text.Json.Serialization;
 using System.Text;
 using System.Threading.Tasks;
 
@@ -69,10 +70,33 @@ public static async Task<List<FunctionParameterInfo>> GetFunctionParameterInfoAs
             List<FunctionParameterInfo> result = new List<FunctionParameterInfo>();
             foreach (var prop in props)
             {
+                if (ShouldIgnoreProperty(prop))
+                {
+                    continue;
+                }
+
                 SelectionList selectionList = null;
+                var filterable = false;
+                var allowCreate = false;
                 parameterType = ParameterType.Text;//默认为文本内容
-                                                   //判断是否存在选项
-                if (prop.PropertyType == typeof(SelectionList))
+
+                var functionParameterUi = prop.GetCustomAttribute<FunctionParameterUiAttribute>();
+                if (functionParameterUi != null)
+                {
+                    parameterType = functionParameterUi.ParameterType;
+                    filterable = functionParameterUi.Filterable;
+                    allowCreate = functionParameterUi.AllowCreate;
+
+                    if (!functionParameterUi.SelectionListPropertyName.IsNullOrEmpty() && paraObj != null)
+                    {
+                        var selectionProp = functionParameterType.GetProperty(functionParameterUi.SelectionListPropertyName);
+                        if (selectionProp?.PropertyType == typeof(SelectionList))
+                        {
+                            selectionList = selectionProp.GetValue(paraObj, null) as SelectionList;
+                        }
+                    }
+                }
+                else if (prop.PropertyType == typeof(SelectionList))
                 {
                     var selections = prop.GetValue(paraObj, null) as SelectionList;
                     switch (selections.SelectionType)
@@ -130,12 +154,23 @@ public static async Task<List<FunctionParameterInfo>> GetFunctionParameterInfoAs
                 }
 
                 var functionParamInfo = new FunctionParameterInfo(name, title, description, isRequired, systemType, parameterType,
-                                                selectionList ?? new SelectionList(SelectionType.Unknown), value, maxLength);
+                                                selectionList ?? new SelectionList(SelectionType.Unknown), value, maxLength,
+                                                filterable, allowCreate);
                 result.Add(functionParamInfo);
             }
             return result;
         }
 
+        private static bool ShouldIgnoreProperty(PropertyInfo propertyInfo)
+        {
+            if (propertyInfo.GetCustomAttribute<JsonIgnoreAttribute>() != null)
+            {
+                return true;
+            }
+
+            return propertyInfo.CustomAttributes.Any(z => z.AttributeType.FullName == "Newtonsoft.Json.JsonIgnoreAttribute");
+        }
+
         /// <summary>
         /// 给 SelectionList 对象添加当前解决方案中的 XNCF 项目
         /// （扫描当前解决方案包含的所有领域项目）