Handle DynamicMethod reflection limitations in AIFunctionFactory

src/Libraries/Microsoft.Extensions.AI.Abstractions/Functions/AIFunctionFactory.cs

@@ -704,7 +704,7 @@ private ReflectionAIFunctionDescriptor(DescriptorKey key, JsonSerializerOptions
             JsonSerializerOptions = serializerOptions;
             ReturnJsonSchema = returnType is null || key.ExcludeResultSchema ? null : AIJsonUtilities.CreateJsonSchema(
                 NormalizeReturnType(returnType, serializerOptions),
-                description: key.Method.ReturnParameter.GetCustomAttribute<DescriptionAttribute>(inherit: true)?.Description,
+                description: GetReturnParameterDescription(key.Method),
                 serializerOptions: serializerOptions,
                 inferenceOptions: schemaOptions);
 
@@ -1093,6 +1093,19 @@ private static bool IsAIContentRelatedType(Type type) =>
             typeof(AIContent).IsAssignableFrom(type) ||
             typeof(IEnumerable<AIContent>).IsAssignableFrom(type);
 
+        private static string? GetReturnParameterDescription(MethodInfo method)
+        {
+            try
+            {
+                return method.ReturnParameter.GetCustomAttribute<DescriptionAttribute>(inherit: true)?.Description;
+            }
+            catch (Exception e) when (e is ArgumentNullException or NullReferenceException)
+            {
+                // DynamicMethod return parameters don't support GetCustomAttribute.
+                return null;
+            }
+        }
+
         private static Type NormalizeReturnType(Type type, JsonSerializerOptions? options)
         {
             options ??= AIJsonUtilities.DefaultOptions;

src/Libraries/Microsoft.Extensions.AI.Abstractions/Utilities/AIJsonUtilities.Schema.Create.cs

@@ -20,6 +20,7 @@
 
 #pragma warning disable S1075 // URIs should not be hardcoded
 #pragma warning disable S1199 // Nested block
+#pragma warning disable S1696 // NullReferenceException should not be caught
 #pragma warning disable SA1118 // Parameter should not span multiple lines
 
 namespace Microsoft.Extensions.AI;
@@ -343,7 +344,7 @@ JsonNode TransformSchemaNode(JsonSchemaExporterContext schemaExporterContext, Js
                 }
                 else if (parameter is not null &&
                     !ctx.TypeInfo.Type.IsValueType &&
-                    nullabilityContext?.Create(parameter).WriteState is NullabilityState.Nullable)
+                    GetNullableWriteState(nullabilityContext, parameter) is NullabilityState.Nullable)
                 {
                     // Handle nullable reference type parameters (e.g., object?).
                     if (objSchema.TryGetPropertyValue(TypePropertyName, out JsonNode? typeKeyWord) &&
@@ -833,4 +834,23 @@ internal static bool TryGetEffectiveDefaultValue(ParameterInfo parameterInfo, ou
 
         return defaultValue;
     }
+
+    private static NullabilityState? GetNullableWriteState(NullabilityInfoContext? nullabilityContext, ParameterInfo parameter)
+    {
+        if (nullabilityContext is not null)
+        {
+            try
+            {
+                return nullabilityContext.Create(parameter).WriteState;
+            }
+            catch (NullReferenceException)
+            {
+                // NullabilityInfoContext can throw for parameters that lack complete reflection metadata
+                // (e.g. DynamicMethod parameters). cf. https://github.com/dotnet/runtime/pull/124293
+                return NullabilityState.Unknown;
+            }
+        }
+
+        return null;
+    }
 }

test/Libraries/Microsoft.Extensions.AI.Tests/Functions/AIFunctionFactoryTest.cs

@@ -6,6 +6,7 @@
 using System.ComponentModel;
 using System.Linq;
 using System.Reflection;
+using System.Reflection.Emit;
 using System.Text.Json;
 using System.Text.Json.Nodes;
 using System.Text.Json.Serialization;
@@ -1418,6 +1419,42 @@ public void JsonSchema_NullableReferenceTypeParameters_AllowNull()
         Assert.DoesNotContain("nullableIntWithDefault", requiredParams);
     }
 
+    [Fact]
+    public async Task AIFunctionFactory_DynamicMethod()
+    {
+        DynamicMethod dynamicMethod = new DynamicMethod(
+            "DoubleIt",
+            typeof(Task<int>),
+            new[] { typeof(int) },
+            typeof(AIFunctionFactoryTest).Module);
+
+        dynamicMethod.DefineParameter(1, ParameterAttributes.None, "value");
+
+        ILGenerator il = dynamicMethod.GetILGenerator();
+        il.Emit(OpCodes.Ldarg_0);
+        il.Emit(OpCodes.Ldc_I4_2);
+        il.Emit(OpCodes.Mul);
+        il.Emit(OpCodes.Call, typeof(Task).GetMethod(nameof(Task.FromResult))!.MakeGenericMethod(typeof(int)));
+        il.Emit(OpCodes.Ret);
+
+        Delegate testDelegate = dynamicMethod.CreateDelegate(typeof(Func<int, Task<int>>));
+
+        AIFunction func = AIFunctionFactory.Create(testDelegate.GetMethodInfo(), testDelegate.Target);
+
+        Assert.Equal("DoubleIt", func.Name);
+
+        JsonElement schema = func.JsonSchema;
+        JsonElement properties = schema.GetProperty("properties");
+        Assert.True(properties.TryGetProperty("value", out _));
+
+#if NET
+        // DynamicMethod invocation via MethodInfo.Invoke is not supported on .NET Framework.
+        object? result = await func.InvokeAsync(new() { ["value"] = 21 });
+        Assert.IsType<JsonElement>(result);
+        Assert.Equal(42, ((JsonElement)result!).GetInt32());
+#endif
+    }
+
     [JsonSerializable(typeof(IAsyncEnumerable<int>))]
     [JsonSerializable(typeof(int[]))]
     [JsonSerializable(typeof(string))]