Adding ctor for init on function metadata

Author: rogerbarreto

dotnet/src/SemanticKernel.Abstractions/Functions/KernelFunctionMetadata.cs

@@ -34,6 +34,37 @@ public KernelFunctionMetadata(string name)
         this.Name = name;
     }
 
+    /// <summary>Initializes the <see cref="KernelFunctionMetadata"/> with all properties.</summary>
+    /// <param name="name">The name of the function.</param>
+    /// <param name="pluginName">The name of the plugin containing the function.</param>
+    /// <param name="description">The description of the function.</param>
+    /// <param name="parameters">The metadata for the parameters to the function.</param>
+    /// <param name="returnParameter">The metadata for the return parameter.</param>
+    /// <param name="additionalProperties">Optional metadata in addition to the named properties.</param>
+    /// <exception cref="ArgumentNullException">The <paramref name="name"/> was null.</exception>
+    /// <exception cref="ArgumentException">An invalid name was supplied.</exception>
+    public KernelFunctionMetadata(
+        string name,
+        string? pluginName = null,
+        string? description = null,
+        IReadOnlyList<KernelParameterMetadata>? parameters = null,
+        KernelReturnParameterMetadata? returnParameter = null,
+        ReadOnlyDictionary<string, object?>? additionalProperties = null)
+        : this(name)
+    {
+        this.PluginName = pluginName;
+        this.Description = description;
+        this.Parameters = parameters ?? [];
+        if (returnParameter is not null)
+        {
+            this.ReturnParameter = returnParameter;
+        }
+        if (additionalProperties is not null)
+        {
+            this.AdditionalProperties = additionalProperties;
+        }
+    }
+
     /// <summary>Initializes a <see cref="KernelFunctionMetadata"/> as a copy of another <see cref="KernelFunctionMetadata"/>.</summary>
     /// <exception cref="ArgumentNullException">The <paramref name="metadata"/> was null.</exception>
     /// <remarks>

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

@@ -1,5 +1,6 @@
 // Copyright (c) Microsoft. All rights reserved.
 
+using System;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.ComponentModel;
@@ -232,6 +233,159 @@ public void CopyConstructorCopiesPropertiesValues()
         Assert.Equal(original.ReturnParameter, copy.ReturnParameter);
     }
 
+    [Fact]
+    public void ItCanBeConstructedWithAllParameters()
+    {
+        // Test the new constructor that accepts all parameters
+        var parameters = new List<KernelParameterMetadata>
+        {
+            new("param1", "First parameter", "default1", true, typeof(string)),
+            new("param2", "Second parameter", 42, false, typeof(int))
+        };
+        var returnParameter = new KernelReturnParameterMetadata("Return description", typeof(bool));
+        var additionalProperties = new ReadOnlyDictionary<string, object?>(new Dictionary<string, object?>
+        {
+            { "method", "GET" },
+            { "endpoint", "/test" }
+        });
+
+        var metadata = new KernelFunctionMetadata(
+            name: "TestFunction",
+            pluginName: "TestPlugin",
+            description: "Test function description",
+            parameters: parameters,
+            returnParameter: returnParameter,
+            additionalProperties: additionalProperties);
+
+        Assert.Equal("TestFunction", metadata.Name);
+        Assert.Equal("TestPlugin", metadata.PluginName);
+        Assert.Equal("Test function description", metadata.Description);
+        Assert.Equal(parameters, metadata.Parameters);
+        Assert.Equal(returnParameter, metadata.ReturnParameter);
+        Assert.Equal(additionalProperties, metadata.AdditionalProperties);
+    }
+
+    [Fact]
+    public void ItUsesDefaultValuesInNewConstructor()
+    {
+        // Test that optional parameters have correct default values
+        var metadata = new KernelFunctionMetadata("TestFunction");
+
+        Assert.Equal("TestFunction", metadata.Name);
+        Assert.Null(metadata.PluginName);
+        Assert.Empty(metadata.Description);
+        Assert.Empty(metadata.Parameters);
+        Assert.NotNull(metadata.ReturnParameter); // Should be default empty instance
+        Assert.Empty(metadata.AdditionalProperties);
+    }
+
+    [Fact]
+    public void ItThrowsForInvalidNameInNewConstructor()
+    {
+        // Test that the new constructor still validates the name parameter
+        Assert.Throws<ArgumentNullException>(() => new KernelFunctionMetadata(null!, "plugin"));
+        Assert.Throws<ArgumentException>(() => new KernelFunctionMetadata("", "plugin"));
+        Assert.Throws<ArgumentException>(() => new KernelFunctionMetadata("   ", "plugin"));
+        Assert.Throws<ArgumentException>(() => new KernelFunctionMetadata("invalid-name!", "plugin"));
+    }
+
+    [Fact]
+    public void ItHandlesNullDescriptionInNewConstructor()
+    {
+        // Test that null description is handled correctly
+        var metadata = new KernelFunctionMetadata(
+            name: "TestFunction",
+            pluginName: "TestPlugin",
+            description: null);
+
+        Assert.Equal("TestFunction", metadata.Name);
+        Assert.Equal("TestPlugin", metadata.PluginName);
+        Assert.Empty(metadata.Description); // null description should become empty string
+    }
+
+    [Fact]
+    public void ItHandlesNullParametersInNewConstructor()
+    {
+        // Test that null parameters list is handled correctly
+        var metadata = new KernelFunctionMetadata(
+            name: "TestFunction",
+            parameters: null);
+
+        Assert.Equal("TestFunction", metadata.Name);
+        Assert.Empty(metadata.Parameters); // null parameters should become empty list
+    }
+
+    [Fact]
+    public void ItHandlesNullReturnParameterInNewConstructor()
+    {
+        // Test that null return parameter is handled correctly
+        var metadata = new KernelFunctionMetadata(
+            name: "TestFunction",
+            returnParameter: null);
+
+        Assert.Equal("TestFunction", metadata.Name);
+        Assert.NotNull(metadata.ReturnParameter); // Should use default empty instance
+        Assert.Empty(metadata.ReturnParameter.Description);
+    }
+
+    [Fact]
+    public void ItHandlesNullAdditionalPropertiesInNewConstructor()
+    {
+        // Test that null additional properties is handled correctly
+        var metadata = new KernelFunctionMetadata(
+            name: "TestFunction",
+            additionalProperties: null);
+
+        Assert.Equal("TestFunction", metadata.Name);
+        Assert.Empty(metadata.AdditionalProperties); // Should use default empty dictionary
+    }
+
+    [Fact]
+    public void ItCanBeConstructedWithOnlyNameAndDescription()
+    {
+        // Test constructor with only name and description
+        var metadata = new KernelFunctionMetadata(
+            name: "TestFunction",
+            description: "Test description");
+
+        Assert.Equal("TestFunction", metadata.Name);
+        Assert.Null(metadata.PluginName);
+        Assert.Equal("Test description", metadata.Description);
+        Assert.Empty(metadata.Parameters);
+        Assert.NotNull(metadata.ReturnParameter);
+        Assert.Empty(metadata.AdditionalProperties);
+    }
+
+    [Fact]
+    public void ItCanBeConstructedWithNameAndPluginName()
+    {
+        // Test constructor with name and plugin name
+        var metadata = new KernelFunctionMetadata(
+            name: "TestFunction",
+            pluginName: "TestPlugin");
+
+        Assert.Equal("TestFunction", metadata.Name);
+        Assert.Equal("TestPlugin", metadata.PluginName);
+        Assert.Empty(metadata.Description);
+        Assert.Empty(metadata.Parameters);
+        Assert.NotNull(metadata.ReturnParameter);
+        Assert.Empty(metadata.AdditionalProperties);
+    }
+
+    [Fact]
+    public void ItCanBeConstructedWithEmptyParametersList()
+    {
+        // Test constructor with explicitly empty parameters list
+        var emptyParameters = new List<KernelParameterMetadata>();
+        var metadata = new KernelFunctionMetadata(
+            name: "TestFunction",
+            parameters: emptyParameters);
+
+        Assert.Equal("TestFunction", metadata.Name);
+        Assert.Empty(metadata.Parameters);
+        Assert.Same(emptyParameters, metadata.Parameters);
+    }
+
     private static void ValidFunctionName() { }
     private static async Task ValidFunctionNameAsync()
     {