fix: MeaiFunction ignoring simple values types arguments

refactor: Simplified JsonSchema generation codes

Author: Gunpal Jain

src/libs/CSharpToJsonSchema.Generators/Conversion/ToModels.cs

@@ -37,8 +37,6 @@ public static InterfaceData PrepareData(
                     IsVoid: x.ReturnsVoid || x.ReturnType.MetadataName == "Task",
                     IsStrict: isStrict,
                     Parameters: parameters.Select(static y => y).ToArray(),
-                    Descriptions: parameters.Select(static l => GetParameterDescriptions(l)).SelectMany(s => s)
-                        .ToDictionary(s => s.Key, s => s.Value),
                     ReturnType: x.ReturnType
                 );
             })
@@ -91,8 +89,6 @@ public static InterfaceData PrepareMethodData(
                 IsVoid: x.ReturnsVoid || x.ReturnType.MetadataName == "Task",
                 IsStrict: isStrict,
                 Parameters: parameters.Select(static y => y).ToArray(),
-                Descriptions: parameters.Select(static l => GetParameterDescriptions(l)).SelectMany(s => s)
-                    .ToDictionary(s => s.Key, s => s.Value),
                 ReturnType:x.ReturnType
             );
             methodList.Add(methodData);

src/libs/CSharpToJsonSchema.Generators/Models/MethodData.cs

@@ -9,7 +9,6 @@ public readonly record struct MethodData(
     bool IsVoid,
     bool IsStrict,
     IParameterSymbol[] Parameters,
-    Dictionary<string, string> Descriptions,
     ITypeSymbol ReturnType);
 
 public readonly record struct PropertyMetadata(string Name, string Description, bool IsRequired);

src/libs/CSharpToJsonSchema.Generators/Sources.Tools.cs

@@ -97,7 +97,7 @@ private static string GetDictionaryString(MethodData data)
     {
         StringBuilder sb = new StringBuilder();
 
-        var methodDescriptions = data.Descriptions;
+        var methodDescriptions = new Dictionary<string, string>();
         methodDescriptions.Add("MainFunction_Desc", data.Description);
         sb.Append("{");
         var lst = methodDescriptions.Select(s => $"\"{s.Key.ToCamelCase()}\":\"{s.Value}\"");

src/libs/CSharpToJsonSchema/MeaiFunction.cs

@@ -88,6 +88,8 @@ private string GetArgsString(IEnumerable<KeyValuePair<string, object?>> argument
                     jsonObject[args.Key] = JsonArray.Create(element);
                 else if (element.ValueKind == JsonValueKind.Object)
                     jsonObject[args.Key] = JsonObject.Create(element);
+                else
+                    jsonObject[args.Key] = JsonValue.Create(element);
             }
             else if (args.Value is JsonNode node)
             {

src/libs/CSharpToJsonSchema/SchemaSubsetHelper.cs

@@ -1,4 +1,6 @@
-using System.Text.Json.Nodes;
+using System.ComponentModel;
+using System.Reflection;
+using System.Text.Json.Nodes;
 using System.Text.Json.Schema;
 using System.Text.Json.Serialization;
 using System.Text.Json.Serialization.Metadata;
@@ -7,151 +9,120 @@ namespace CSharpToJsonSchema;
 
 public static class SchemaBuilder
 {
-    /// <summary>
-    /// Converts a JSON document that contains valid json schema <see href="https://json-schema.org/specification"/> as e.g. 
-    /// generated by <code>Microsoft.Extensions.AI.AIJsonUtilities.CreateJsonSchema</code> or <code>JsonSchema.Net</code>'s
-    /// <see cref="JsonSchemaBuilder"/> to a subset that is compatible with LLM's APIs.
-    /// </summary>
-    /// <param name="constructedSchema">Generated, valid json schema.</param>
-    /// <returns>Subset of the given json schema in a LLM-compatible format.</returns>
-    public static OpenApiSchema ConvertToCompatibleSchemaSubset(JsonNode node)
-    {
-        ConvertNullableProperties(node);
-        var x1 = node;
-        var x2 = x1.ToJsonString();
-        var schema = JsonSerializer.Deserialize(x2, OpenApiSchemaJsonContext.Default.OpenApiSchema);
-        return schema;
-    }
-
-    private static void ConvertNullableProperties(JsonNode? node)
-    {
-        // If the node is an object, look for a "type" property or nested definitions
-        if (node is JsonObject obj)
-        {
-            // If "type" is an array, remove "null" and collapse if it leaves only one type
-            if (obj.TryGetPropertyValue("type", out var typeValue) && typeValue is JsonArray array)
-            {
-                if (array.Count == 2)
-                {
-                    var notNullTypes = array.Where(x => x is not null && x.GetValue<string>() != "null").ToList();
-                    if (notNullTypes.Count == 1)
-                    {
-                        obj["type"] = notNullTypes[0]!.GetValue<string>();
-                        obj["nullable"] = true;
-                    }
-                    else
-                    {
-                        throw new InvalidOperationException(
-                            $"LLM's API for strucutured output requires every property to have one defined type, not multiple options. Path: {obj.GetPath()} Schema: {obj.ToJsonString()}");
-                    }
-                }
-                else if (array.Count > 2)
-                {
-                    throw new InvalidOperationException(
-                        $"LLM's API for strucutured output requires every property to have one defined type, not multiple options. Path: {obj.GetPath()} Schema: {obj.ToJsonString()}");
-                }
-            }
-
-            // Recursively convert any nested schema in "properties"
-            if (obj.TryGetPropertyValue("properties", out var propertiesNode) &&
-                propertiesNode is JsonObject propertiesObj)
-            {
-                foreach (var property in propertiesObj)
-                {
-                    ConvertNullableProperties(property.Value);
-                }
-            }
-
-            if (obj.TryGetPropertyValue("type", out var newTypeValue)
-                && newTypeValue is JsonNode
-                && newTypeValue.GetValueKind() == JsonValueKind.String
-                && "object".Equals(newTypeValue.GetValue<string>(), StringComparison.OrdinalIgnoreCase)
-                && propertiesNode is not JsonObject)
-            {
-                throw new InvalidOperationException(
-                    $"LLM's API for strucutured output requires every object to have predefined properties. Notably, it does not support dictionaries. Path: {obj.GetPath()} Schema: {obj.ToJsonString()}");
-            }
-
-            // Recursively convert any nested schema in "items"
-            if (obj.TryGetPropertyValue("items", out var itemsNode))
-            {
-                ConvertNullableProperties(itemsNode);
-            }
-        }
-
-        // If the node is an array, traverse each element
-        if (node is JsonArray arr)
-        {
-            foreach (var element in arr)
-            {
-                ConvertNullableProperties(element);
-            }
-        }
-    }
-
-    public static OpenApiSchema ConvertToSchema<T>(JsonSerializerOptions? jsonOptions = null)
-    {
-        if (jsonOptions == null && !JsonSerializer.IsReflectionEnabledByDefault)
-        {
-            throw new InvalidOperationException("Please provide a JsonSerializerOptions instance to use in AOT mode.");
-        }
-
-
-        var newJsonOptions = new JsonSerializerOptions(jsonOptions)
-        {
-            NumberHandling = JsonNumberHandling.Strict
-        };
-
-        var typeInfo = newJsonOptions.GetTypeInfo(typeof(T));
-
-        return ConvertToCompatibleSchemaSubset(typeInfo.GetJsonSchemaAsNode());
-    }
-
+   
     public static OpenApiSchema ConvertToSchema(JsonTypeInfo type, string descriptionString)
     {
         var typeInfo = type;
 
         var dics = JsonSerializer.Deserialize(descriptionString,
             OpenApiSchemaJsonContext.Default.IDictionaryStringString);
         List<string> required = new List<string>();
-        var x = ConvertToCompatibleSchemaSubset(typeInfo.GetJsonSchemaAsNode(
+        var x = typeInfo.GetJsonSchemaAsNode(
             exporterOptions: new JsonSchemaExporterOptions()
             {
-                TransformSchemaNode = (a, b) =>
+                TransformSchemaNode = (context, schema) =>
                 {
-                    if (a.TypeInfo.Type.IsEnum)
+                    if (context.TypeInfo.Type.IsEnum)
                     {
-                        b["type"] = "string";
+                        schema["type"] = "string";
                     }
-
-                    if (a.PropertyInfo == null)
-                        return b;
-                    var propName = ToCamelCase(a.PropertyInfo.Name);
-                    if (dics.ContainsKey(propName))
-                    {
-                        b["description"] = dics[propName];
-                    }
-
-                    return b;
+                
+                    ExtractDescription(context, schema, dics);
+                    if (context.PropertyInfo == null)
+                        return schema;
+               
+                    return schema;
                 },
-            }));
+            });
+        
+        var schema = JsonSerializer.Deserialize(x.ToJsonString(), OpenApiSchemaJsonContext.Default.OpenApiSchema);
 
-
-        foreach (var re in x.Properties)
+        foreach (var re in schema.Properties)
         {
             required.Add(re.Key);
         }
 
-        var mainDescription = x.Description ?? (dics.TryGetValue("mainFunction_Desc", out var desc) ? desc : "");
+        var mainDescription = schema.Description ?? (dics.TryGetValue("mainFunction_Desc", out var desc) ? desc : "");
         return new OpenApiSchema()
         {
             Description = mainDescription,
-            Properties = x.Properties,
+            Properties = schema.Properties,
             Required = required,
             Type = "object"
         };
     }
+    
+    private static void ExtractDescription(JsonSchemaExporterContext context, JsonNode schema, IDictionary<string, string> dics)
+    {
+        // Determine if a type or property and extract the relevant attribute provider.
+        ICustomAttributeProvider? attributeProvider = context.PropertyInfo is not null
+            ? context.PropertyInfo.AttributeProvider
+            : context.TypeInfo.Type;
+
+        // Look up any description attributes.
+        DescriptionAttribute? descriptionAttr = attributeProvider?
+            .GetCustomAttributes(inherit: true)
+            .Select(attr => attr as DescriptionAttribute)
+            .FirstOrDefault(attr => attr is not null);
+
+        var description = descriptionAttr?.Description;
+        if (string.IsNullOrEmpty(description))
+        {
+            if (context.PropertyInfo is null)
+            {
+                var propertyName = ToCamelCase(context.TypeInfo.Type.Name);
+                dics.TryGetValue(propertyName, out description);
+            }
+        }
 
+        FixType(schema);
+        
+        // Apply description attribute to the generated schema.
+        if (description is not null)
+        {
+            if (schema is not JsonObject jObj)
+            {
+                // Handle the case where the schema is a Boolean.
+                JsonValueKind valueKind = schema.GetValueKind();
+                
+                schema = jObj = new JsonObject();
+                if (valueKind is JsonValueKind.False)
+                {
+                    jObj.Add("not", true);
+                }
+            }
+            
+            jObj.Insert(0, "description", description);
+        }
+    }
+
+    private static void FixType(JsonNode schema)
+    {
+        // If "type" is an array, remove "null" and collapse if it leaves only one type
+        var typeValue = schema["type"];
+        if (typeValue!= null && typeValue is JsonArray array)
+        {
+            if (array.Count == 2)
+            {
+                var notNullTypes = array.Where(x => x is not null && x.GetValue<string>() != "null").ToList();
+                if (notNullTypes.Count == 1)
+                {
+                    schema["type"] = notNullTypes[0]!.GetValue<string>();
+                    schema["nullable"] = true;
+                }
+                else
+                {
+                    throw new InvalidOperationException(
+                        $"Google's API for strucutured output requires every property to have one defined type, not multiple options. Path: {schema.GetPath()} Schema: {schema.ToJsonString()}");
+                }
+            }
+            else if (array.Count > 2)
+            {
+                throw new InvalidOperationException(
+                    $"Google's API for strucutured output requires every property to have one defined type, not multiple options. Path: {schema.GetPath()} Schema: {schema.ToJsonString()}");
+            }
+        }
+    }
     public static string ToCamelCase(string str)
     {
         if (!string.IsNullOrEmpty(str) && str.Length > 1)
@@ -161,12 +132,4 @@ public static string ToCamelCase(string str)
 
         return str.ToLowerInvariant();
     }
-
-    public static string ConvertToSchema(Type type, JsonSerializerOptions? jsonOptions)
-    {
-        var node = jsonOptions.GetJsonSchemaAsNode(type);
-        var x = ConvertToCompatibleSchemaSubset(node);
-
-        return JsonSerializer.Serialize(x.Properties, OpenApiSchemaJsonContext.Default.IDictionaryStringOpenApiSchema);
-    }
 }

src/tests/AotConsole/Program.cs

@@ -9,7 +9,7 @@
 if (string.IsNullOrWhiteSpace(key))
     return;
 var prompt = "how does student john doe in senior grade is doing this year, enrollment start 01-01-2024 to 01-01-2025?";
-        
+//prompt = "what is written on page 96 in the book 'damdamadum'";
 var client = new OpenAIClient(new ApiKeyCredential(key));
 
 Microsoft.Extensions.AI.OpenAIChatClient openAiClient = new OpenAIChatClient(client.GetChatClient("gpt-4o-mini"));

src/tests/CSharpToJsonSchema.AotTests/JsonSerializationTests.cs

@@ -127,6 +127,35 @@ public void ShouldCreateToolWithComplexStudentClass()
     {
         var service = new StudenRecordService();
         var tools = service.AsTools();
+
+        Tool tool = tools[0];
+
+
+        var openApiSchema = (OpenApiSchema)tool.Parameters;
+        tool.Description.Should().Be("Get student record for the year");
+        tool.Name.Should().Be("GetStudentRecordAsync");
+        openApiSchema.Properties["query"].Should().NotBeNull();
+
+        openApiSchema.Properties["query"].Properties["fullName"].Type.Should().Be("string");
+        openApiSchema.Properties["query"].Properties["fullName"].Description.Should().Be("The student's full name.");
+
+        openApiSchema.Properties["query"].Properties["gradeFilters"].Type.Should().Be("array");
+        openApiSchema.Properties["query"].Properties["gradeFilters"].Items.Type.Should().Be("string");
+        openApiSchema.Properties["query"].Properties["gradeFilters"].Description.Should()
+            .Be("Grade filters for querying specific grades, e.g., Freshman or Senior.");
+
+        openApiSchema.Properties["query"].Properties["enrollmentStartDate"].Type.Should().Be("string");
+        openApiSchema.Properties["query"].Properties["enrollmentStartDate"].Format.Should().Be("date-time");
+        openApiSchema.Properties["query"].Properties["enrollmentStartDate"].Description.Should()
+            .Be("The start date for the enrollment date range. ISO 8601 standard date");
+
+        openApiSchema.Properties["query"].Properties["enrollmentEndDate"].Type.Should().Be("string");
+        openApiSchema.Properties["query"].Properties["enrollmentEndDate"].Format.Should().Be("date-time");
+        openApiSchema.Properties["query"].Properties["enrollmentEndDate"].Description.Should()
+            .Be("The end date for the enrollment date range. ISO 8601 standard date");
+
+        openApiSchema.Properties["query"].Properties["isActive"].Type.Should().Be("boolean");
+        openApiSchema.Properties["query"].Properties["isActive"].Description.Should()
+            .Be("The flag indicating whether to include only active students.");
     }
-   
 }