.Net: Fix enum deserialization mismatch between schema and tool calls

KernelJsonSchemaBuilder uses JsonStringEnumConverter when generating
tool parameter schemas, telling LLMs to return enum values as strings.
However, KernelFunctionFromMethod.TryToDeserializeValue did not use
the same converter when deserializing LLM responses, causing
JsonException for any function with enum parameters.

Fall back to KernelJsonSchemaBuilder's default options (which include
JsonStringEnumConverter) when no explicit JsonSerializerOptions are
provided, ensuring schema generation and deserialization stay in sync.

Closes #13589

Author: weiguangli-io

dotnet/src/InternalUtilities/src/Schema/KernelJsonSchemaBuilder.cs

@@ -61,7 +61,7 @@ public static KernelJsonSchema Build(
 
     [RequiresUnreferencedCode("Uses JsonStringEnumConverter and DefaultJsonTypeInfoResolver classes, making it incompatible with AOT scenarios.")]
     [RequiresDynamicCode("Uses JsonStringEnumConverter and DefaultJsonTypeInfoResolver classes, making it incompatible with AOT scenarios.")]
-    private static JsonSerializerOptions GetDefaultOptions()
+    internal static JsonSerializerOptions GetDefaultOptions()
     {
         if (s_options is null)
         {

dotnet/src/SemanticKernel.Core/Functions/KernelFunctionFromMethod.cs

@@ -738,7 +738,7 @@ private static (Func<KernelFunction, Kernel, KernelArguments, CancellationToken,
                     return jsonStringParser(element.GetString()!);
                 }
 
-                if (value is not null && TryToDeserializeValue(value, type, jsonSerializerOptions, out var deserializedValue))
+                if (value is not null && TryToDeserializeValue(value, type, jsonSerializerOptions ?? KernelJsonSchemaBuilder.GetDefaultOptions(), out var deserializedValue))
                 {
                     return deserializedValue;
                 }

dotnet/src/SemanticKernel.UnitTests/Functions/KernelFunctionFromMethodTests1.cs

@@ -755,6 +755,42 @@ public async Task ItSupportsConvertingAllIntegerTypesToEnumAsync(object argument
         Assert.Equal(expected, actual);
     }
 
+    [Theory]
+    [InlineData("\"Sunday\"", DayOfWeek.Sunday)]
+    [InlineData("\"Monday\"", DayOfWeek.Monday)]
+    [InlineData("\"Thursday\"", DayOfWeek.Thursday)]
+    [InlineData("\"Saturday\"", DayOfWeek.Saturday)]
+    public async Task ItSupportsConvertingStringJsonElementToEnumAsync(string json, DayOfWeek expected)
+    {
+        // Arrange
+        object? actual = null;
+        var function = KernelFunctionFactory.CreateFromMethod((DayOfWeek dow) => actual = dow);
+
+        // Act — simulate LLM returning a string enum value as a JsonElement
+        var result = await function.InvokeAsync(this._kernel, new() { ["dow"] = JsonDocument.Parse(json).RootElement });
+
+        // Assert
+        Assert.Equal(expected, actual);
+    }
+
+    [Fact]
+    public async Task ItSupportsConvertingStringEnumNestedInObjectFromJsonElementAsync()
+    {
+        // Arrange — matches the issue scenario: enum nested in an object, then in an array
+        TaskReminder[]? actual = null;
+        var function = KernelFunctionFactory.CreateFromMethod((TaskReminder[] reminders) => actual = reminders);
+        var json = """[{"unit":"Days","value":3}]""";
+
+        // Act — simulate LLM returning a JSON array with string enum values
+        var result = await function.InvokeAsync(this._kernel, new() { ["reminders"] = JsonDocument.Parse(json).RootElement });
+
+        // Assert
+        Assert.NotNull(actual);
+        Assert.Single(actual);
+        Assert.Equal(ReminderUnit.Days, actual[0].Unit);
+        Assert.Equal(3, actual[0].Value);
+    }
+
     [TypeConverter(typeof(MyCustomTypeConverter))]
     private sealed class MyCustomType
     {
@@ -1590,4 +1626,22 @@ private sealed class ThirdPartyJsonPrimitive(string jsonToReturn)
     {
         public override string ToString() => jsonToReturn;
     }
+
+    private enum ReminderUnit
+    {
+        Minutes,
+        Hours,
+        Days,
+    }
+
+#pragma warning disable CA1812 // Avoid uninstantiated internal classes
+    private sealed class TaskReminder
+#pragma warning restore CA1812 // Avoid uninstantiated internal classes
+    {
+        [JsonPropertyName("unit")]
+        public ReminderUnit Unit { get; set; }
+
+        [JsonPropertyName("value")]
+        public int Value { get; set; }
+    }
 }