Address PR feedback: DiagnosticIds merge, netfx fix, duplicate detection, test improvements

Author: Copilot

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

@@ -808,7 +808,11 @@ private ReflectionAIFunctionDescriptor(DescriptorKey key, JsonSerializerOptions
                     pType != typeof(IServiceProvider) &&
                     !string.IsNullOrEmpty(parameters[i].Name))
                 {
-                    _ = expectedArgumentNames.Add(AIJsonUtilities.GetParameterSchemaName(parameters[i]));
+                    string effectiveName = AIJsonUtilities.GetParameterSchemaName(parameters[i]);
+                    if (!expectedArgumentNames.Add(effectiveName))
+                    {
+                        Throw.ArgumentException(nameof(key.Method), $"Multiple parameters are mapped to the same name '{effectiveName}'. Ensure that any {nameof(AIParameterNameAttribute)} values do not collide with each other or with other parameter names.");
+                    }
                 }
             }
 
@@ -1220,9 +1224,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;
             }
         }

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

@@ -14,7 +14,7 @@ namespace Microsoft.Extensions.AI;
 /// By default this is inferred from .NET metadata. Apply this attribute to use a different identifier.
 /// </remarks>
 [AttributeUsage(AttributeTargets.Method, AllowMultiple = false, Inherited = true)]
-[Experimental(DiagnosticIds.Experiments.AIFunctionName, UrlFormat = DiagnosticIds.UrlFormat)]
+[Experimental(DiagnosticIds.Experiments.AIFunctionAndParameterName, UrlFormat = DiagnosticIds.UrlFormat)]
 public sealed class AIFunctionNameAttribute : Attribute
 {
     /// <summary>Initializes a new instance of the <see cref="AIFunctionNameAttribute"/> class.</summary>

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

@@ -14,7 +14,7 @@ namespace Microsoft.Extensions.AI;
 /// By default this is inferred from .NET metadata. Apply this attribute to use a different identifier.
 /// </remarks>
 [AttributeUsage(AttributeTargets.Parameter, AllowMultiple = false, Inherited = true)]
-[Experimental(DiagnosticIds.Experiments.AIParameterName, UrlFormat = DiagnosticIds.UrlFormat)]
+[Experimental(DiagnosticIds.Experiments.AIFunctionAndParameterName, UrlFormat = DiagnosticIds.UrlFormat)]
 public sealed class AIParameterNameAttribute : Attribute
 {
     /// <summary>Initializes a new instance of the <see cref="AIParameterNameAttribute"/> class.</summary>

src/Shared/DiagnosticIds/DiagnosticIds.cs

@@ -54,8 +54,7 @@ internal static class Experiments
         internal const string AIMcpServers = AIExperiments;
         internal const string AIFunctionApprovals = AIExperiments;
         internal const string AIApprovalsInvocationRequired = AIExperiments;
-        internal const string AIFunctionName = AIExperiments;
-        internal const string AIParameterName = AIExperiments;
+        internal const string AIFunctionAndParameterName = AIExperiments;
 
         internal const string AIChatReduction = AIExperiments;
         internal const string AIToolSearch = AIExperiments;

test/Libraries/Microsoft.Extensions.AI.Abstractions.Tests/Utilities/AIJsonUtilitiesTests.cs

@@ -584,18 +584,18 @@ static void TestMethod()
     [Fact]
     public static void CreateFunctionJsonSchema_AIParameterNameAttribute_UsedForPropertyName()
     {
-        Delegate method = ([AIParameterName("$select")] string select, int top) =>
+        Delegate method = ([AIParameterName("custom_property_name")] string select, int top) =>
         {
         };
 
         JsonElement schema = AIJsonUtilities.CreateFunctionJsonSchema(method.Method);
 
         JsonElement properties = schema.GetProperty("properties");
-        Assert.True(properties.TryGetProperty("$select", out _));
+        Assert.True(properties.TryGetProperty("custom_property_name", out _));
         Assert.False(properties.TryGetProperty("select", out _));
 
         string[] required = schema.GetProperty("required").EnumerateArray().Select(e => e.GetString()!).ToArray();
-        Assert.Contains("$select", required);
+        Assert.Contains("custom_property_name", required);
         Assert.Contains("top", required);
     }
 
@@ -627,6 +627,26 @@ public static void CreateFunctionJsonSchema_AIParameterNameAttribute_EscapesJson
         Assert.DoesNotContain("#/properties/a/b~c", schema);
     }
 
+    [Fact]
+    public static void CreateFunctionJsonSchema_AIFunctionNameAttribute_NotUsedForSchemaTitle()
+    {
+        // AIFunctionNameAttribute overrides the AI-facing function name but does not affect the JSON schema title.
+        Delegate method = [AIFunctionName("my_tool")] (string param) => { };
+
+        JsonElement schema = AIJsonUtilities.CreateFunctionJsonSchema(method.Method);
+
+        // The schema title is not derived from AIFunctionNameAttribute.
+        Assert.False(schema.TryGetProperty("title", out JsonElement titleElement) && titleElement.GetString() == "my_tool");
+    }
+
+    [Fact]
+    public static void CreateFunctionJsonSchema_AIFunctionNameAttribute_HonoredByAIFunctionFactory()
+    {
+        Func<string> funcWithAttribute = [AIFunctionName("get_user")] () => "test";
+        AIFunction func = AIFunctionFactory.Create(funcWithAttribute);
+        Assert.Equal("get_user", func.Name);
+    }
+
     [Fact]
     public static void CreateJsonSchema_CanBeBoolean()
     {

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

@@ -10,6 +10,7 @@
 using System.Text.Json;
 using System.Text.Json.Nodes;
 using System.Text.Json.Serialization;
+using System.Text.Json.Serialization.Metadata;
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.Extensions.DependencyInjection;
@@ -18,6 +19,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 (accessed 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
@@ -338,16 +340,154 @@ public async Task Parameters_MappedByAIParameterNameAttribute_Async()
     {
         AIFunction func = AIFunctionFactory.Create(([AIParameterName("$select")] string select, int top) => select + top);
 
-        AssertExtensions.EqualFunctionCallResults("Name2", await func.InvokeAsync(new()
-        {
-            ["$select"] = "Name",
-            ["top"] = 2,
-        }));
+        AssertExtensions.EqualFunctionCallResults("Name2", await func.InvokeAsync(new() { ["$select"] = "Name", ["top"] = 2 }));
 
         ArgumentException ex = await Assert.ThrowsAsync<ArgumentException>(() => func.InvokeAsync(new() { ["top"] = 2 }).AsTask());
         Assert.Contains("$select", ex.Message);
     }
 
+    [Fact]
+    public void AIParameterNameAttribute_OverridesSchemaPropertyName()
+    {
+        AIFunction func = AIFunctionFactory.Create(
+            ([AIParameterName("my_param")] string myParam, int top) => myParam + top);
+
+        JsonElement expectedSchema = JsonDocument.Parse("""
+            {
+                "type": "object",
+                "properties": {
+                    "my_param": { "type": "string" },
+                    "top": { "type": "integer" }
+                },
+                "required": ["my_param", "top"]
+            }
+            """).RootElement;
+
+        AssertExtensions.EqualJsonValues(expectedSchema, func.JsonSchema);
+    }
+
+    [Fact]
+    public async Task AIParameterNameAttribute_BindsArgumentByOverriddenName_Async()
+    {
+        AIFunction func = AIFunctionFactory.Create(
+            ([AIParameterName("$select")] string select,
+             [AIParameterName("$expand")] string expand,
+             string filter) =>
+                $"select='{select}', expand='{expand}', filter='{filter}'");
+
+        object? result = await func.InvokeAsync(new()
+        {
+            ["$select"] = "Name,Id",
+            ["$expand"] = "Orders",
+            ["filter"] = "Active",
+        });
+
+        AssertExtensions.EqualFunctionCallResults("select='Name,Id', expand='Orders', filter='Active'", result);
+    }
+
+    [Fact]
+    public async Task AIParameterNameAttribute_MissingRequiredArgument_ReportsSchemaName_Async()
+    {
+        AIFunction func = AIFunctionFactory.Create(
+            ([AIParameterName("my_param")] string myParam) => myParam);
+
+        ArgumentException ex = await Assert.ThrowsAsync<ArgumentException>(() => func.InvokeAsync().AsTask());
+
+        Assert.Contains("my_param", ex.Message);
+    }
+
+    [Fact]
+    public async Task AIParameterNameAttribute_HonoredByStrictUnmappedMemberHandling_Async()
+    {
+        JsonSerializerOptions strictOptions = new(AIJsonUtilities.DefaultOptions)
+        {
+            UnmappedMemberHandling = JsonUnmappedMemberHandling.Disallow,
+        };
+
+        AIFunction func = AIFunctionFactory.Create(
+            ([AIParameterName("my_param")] string myParam) => myParam,
+            new AIFunctionFactoryOptions { SerializerOptions = strictOptions });
+
+        // The overridden name is "expected", so it passes strict validation.
+        AssertExtensions.EqualFunctionCallResults("Name", await func.InvokeAsync(new() { ["my_param"] = "Name" }));
+
+        // The underlying C# name is now an unexpected argument.
+        ArgumentException ex = await Assert.ThrowsAsync<ArgumentException>("arguments", async () =>
+            await func.InvokeAsync(new() { ["myParam"] = "Name" }));
+        Assert.Contains("myParam", ex.Message);
+    }
+
+    [Fact]
+    public async Task AIParameterNameAttribute_InheritedByOverride_Async()
+    {
+        MethodInfo overrideMethod = typeof(MyDerivedType).GetMethod(nameof(MyDerivedType.Method))!;
+        AIFunction func = AIFunctionFactory.Create(overrideMethod, new MyDerivedType());
+
+        Assert.Contains("my_param", func.JsonSchema.ToString());
+        Assert.DoesNotContain("\"myParam\"", func.JsonSchema.ToString());
+
+        AssertExtensions.EqualFunctionCallResults("param='Name'", await func.InvokeAsync(new() { ["my_param"] = "Name" }));
+    }
+
+    [Fact]
+    public async Task AIFunctionAndParameterNameAttributes_BothHonored_Async()
+    {
+        AIFunction func = AIFunctionFactory.Create([AIFunctionName("my_tool")] ([AIParameterName("my_param")] string myParam) => myParam);
+
+        Assert.Equal("my_tool", func.Name);
+        Assert.Contains("my_param", func.JsonSchema.ToString());
+
+        AssertExtensions.EqualFunctionCallResults("Name", await func.InvokeAsync(new() { ["my_param"] = "Name" }));
+    }
+
+    [Fact]
+    public void AIFunctionAndParameterNameAttributes_NameAndParameterSchema_PreservedByAsDeclarationOnly()
+    {
+        AIFunction func = AIFunctionFactory.Create([AIFunctionName("my_tool")] ([AIParameterName("my_param")] string myParam) => myParam);
+
+        AIFunctionDeclaration declaration = func.AsDeclarationOnly();
+
+        Assert.Equal("my_tool", declaration.Name);
+        Assert.Equal(func.JsonSchema.ToString(), declaration.JsonSchema.ToString());
+        Assert.Contains("my_param", declaration.JsonSchema.ToString());
+        Assert.IsNotAssignableFrom<AIFunction>(declaration);
+    }
+
+    [Fact]
+    public void AIParameterNameAttribute_EscapesNameInJsonPointerRef()
+    {
+        JsonSerializerOptions options = new(AIJsonUtilities.DefaultOptions) { TypeInfoResolver = new DefaultJsonTypeInfoResolver() };
+
+        AIFunction func = AIFunctionFactory.Create(
+            ([AIParameterName("a/b~c")] AIParameterNameAttributeRecursiveNode node) => node.ToString(),
+            new AIFunctionFactoryOptions { SerializerOptions = options });
+
+        string schema = func.JsonSchema.ToString();
+
+        Assert.Contains("#/properties/a~1b~0c", schema);
+        Assert.DoesNotContain("#/properties/a/b~c", schema);
+    }
+
+    [Fact]
+    public void AIParameterNameAttribute_DuplicateNames_Throw()
+    {
+        ArgumentException ex = Assert.Throws<ArgumentException>(() => AIFunctionFactory.Create(
+            ([AIParameterName("dup")] string first, [AIParameterName("dup")] string second) => first + second));
+        Assert.Contains("dup", ex.Message);
+
+        ArgumentException ex2 = Assert.Throws<ArgumentException>(() => AIFunctionFactory.Create(
+            ([AIParameterName("filter")] string select, string filter) => select + filter));
+        Assert.Contains("filter", ex2.Message);
+    }
+
+    [Fact]
+    public void AIFunctionNameAttribute_DisplayNameAttribute_StillHonoredWhenNoAIFunctionNameAttribute()
+    {
+        AIFunction func = AIFunctionFactory.Create([DisplayName("from-display-name")] () => "result");
+
+        Assert.Equal("from-display-name", func.Name);
+    }
+
     [Fact]
     public void AIFunctionFactoryCreateOptions_ValuesPropagateToAIFunction()
     {
@@ -1625,4 +1765,19 @@ public async Task Parameters_UnmappedMemberHandlingDisallow_CustomBindParameter_
     [JsonSerializable(typeof(int?))]
     [JsonSerializable(typeof(DateTime?))]
     private partial class JsonContext : JsonSerializerContext;
+
+    private abstract class MyBaseType
+    {
+        public abstract string Method([AIParameterName("my_param")] string myParam);
+    }
+
+    private sealed class MyDerivedType : MyBaseType
+    {
+        public override string Method(string myParam) => $"param='{myParam}'";
+    }
+
+    private sealed class AIParameterNameAttributeRecursiveNode
+    {
+        public AIParameterNameAttributeRecursiveNode? Next { get; set; }
+    }
 }