Fix IndexOutOfRangeException reading inherited return-parameter description on .NET Framework

On .NET Framework, reading an inherited [Description] from the return
parameter of an overriding method throws IndexOutOfRangeException:
System.Attribute.GetParentDefinition indexes the result of GetParameters()
with the return parameter's Position, which is -1. GetReturnParameterDescription
calls GetCustomAttribute(inherit: true) on method.ReturnParameter, so any
AIFunction created from such an override would throw instead of producing a
schema.

Modern .NET already guards this case (returning the base method's return
parameter), so the failure is .NET Framework only and cannot be fixed there.
Extend the existing catch filter to also treat IndexOutOfRangeException as
"description absent", alongside the DynamicMethod ArgumentNullException/
NullReferenceException cases. On .NET Framework the inherited return
description is silently dropped; on modern .NET it is preserved.

Add a dedicated regression test with TFM-conditional assertions covering the
method-level, ordinary-parameter, and return-parameter inherited descriptions
on an overriding method.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: jozkee

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

@@ -1003,7 +1003,7 @@ static bool IsAsyncMethod(MethodInfo method)
                 // If the parameter is required and there's no argument specified for it, throw.
                 if (!hasDefaultValue)
                 {
-                    Throw.ArgumentException(nameof(arguments), $"The arguments dictionary is missing a value for the required parameter '{parameter.Name}'.");
+                    Throw.ArgumentException(nameof(arguments), $"The arguments dictionary is missing a value for the required parameter '{argumentName}'.");
                 }
 
                 // Otherwise, use the optional parameter's default value.
@@ -1221,9 +1221,11 @@ private static bool IsAIContentRelatedType(Type type) =>
             {
                 return method.ReturnParameter.GetCustomAttribute<DescriptionAttribute>(inherit: true)?.Description;
             }
-            catch (Exception e) when (e is ArgumentNullException or NullReferenceException)
+            catch (Exception e) when (e is ArgumentNullException or NullReferenceException or IndexOutOfRangeException)
             {
-                // DynamicMethod return parameters don't support GetCustomAttribute.
+                // DynamicMethod return parameters don't support GetCustomAttribute. Additionally, on .NET Framework,
+                // querying inherited attributes on the return parameter of an overriding method can throw
+                // IndexOutOfRangeException. In either case, treat the description as absent.
                 return null;
             }
         }

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

@@ -18,6 +18,7 @@
 #pragma warning disable IDE0004 // Remove Unnecessary Cast
 #pragma warning disable S103 // Lines should not be too long
 #pragma warning disable S107 // Methods should not have too many parameters
+#pragma warning disable S1144 // Unused private types or members should be removed (override methods are invoked via reflection)
 #pragma warning disable S2760 // Sequential tests should not check the same condition
 #pragma warning disable S3358 // Ternary operators should not be nested
 #pragma warning disable S5034 // "ValueTask" should be consumed correctly
@@ -1068,6 +1069,40 @@ public void AIFunctionFactory_ReturnTypeWithDescriptionAttribute()
         static int Add(int a, int b) => a + b;
     }
 
+    [Fact]
+    public void AIFunctionFactory_InheritedDescriptionAttributes_OnOverride()
+    {
+        MethodInfo overrideMethod = typeof(DerivedDescribed).GetMethod(nameof(DerivedDescribed.Compute))!;
+        AIFunction f = AIFunctionFactory.Create(overrideMethod, new DerivedDescribed());
+
+        Assert.Equal("The compute method", f.Description);
+
+        JsonElement valueParam = f.JsonSchema.GetProperty("properties").GetProperty("value");
+        Assert.Equal("The input value", valueParam.GetProperty("description").GetString());
+
+        Assert.NotNull(f.ReturnJsonSchema);
+        Assert.Equal("integer", f.ReturnJsonSchema!.Value.GetProperty("type").GetString());
+#if NET
+        // On modern .NET the return-parameter inheritance walk is fixed, so the inherited description is read.
+        Assert.Equal("The computed result", f.ReturnJsonSchema!.Value.GetProperty("description").GetString());
+#else
+        // On .NET Framework the inherited return-parameter description cannot be read and is silently dropped.
+        Assert.False(f.ReturnJsonSchema!.Value.TryGetProperty("description", out _));
+#endif
+    }
+
+    private abstract class BaseDescribed
+    {
+        [Description("The compute method")]
+        [return: Description("The computed result")]
+        public abstract int Compute([Description("The input value")] int value);
+    }
+
+    private sealed class DerivedDescribed : BaseDescribed
+    {
+        public override int Compute(int value) => value;
+    }
+
     [Fact]
     public void CreateDeclaration_Roundtrips()
     {