.Net: Function parameters/arguments type handling fixes (#11211)

### Motivation, Context and Description
This PR fixes the issue where the schema of parameters of `AIFunction`
was not mapped to the schema of parameters of `KernelFunction`. As a
result, the types of parameters of kernel functions were not advertised
to the LLM, leading to the LLM calling the function with arguments of
incorrect types. For example, the LLM called the list_commits function
and provided the string value "4" as an argument for the `perPage`
parameter of the number type.

This PR also adds the `RetainArgumentTypes` function choice behavior
option, which allows preserving the type of function arguments provided
by the LLM for a function call, as opposed to converting the arguments
to strings and losing the type information. Without this option, the
`AIFunctionKernelFunction` invokes `AIFunction` with string arguments,
and as a result, the underlying MCP call fails with the
_ModelContextProtocol.Client.McpClientException: 'Request failed (server
side): Invalid input:
[{"code":"invalid_type","expected":"number","received":"string","path":["perPage"],"message":"Expected
number, received string"}]'_ error, indicating a parameter type
mismatch.

Author: SergeyMenshykh

dotnet/samples/Demos/ModelContextProtocolPlugin/Program.cs

@@ -55,7 +55,7 @@
 OpenAIPromptExecutionSettings executionSettings = new()
 {
     Temperature = 0,
-    FunctionChoiceBehavior = FunctionChoiceBehavior.Auto()
+    FunctionChoiceBehavior = FunctionChoiceBehavior.Auto(options: new() { RetainArgumentTypes = true })
 };
 
 // Test using GitHub tools

dotnet/src/Connectors/Connectors.OpenAI.UnitTests/Core/ClientCoreTests.cs

@@ -289,6 +289,69 @@ public async Task ItShouldReplaceDisallowedCharactersInFunctionName(ChatMessageC
         }
     }
 
+    [Theory]
+    [InlineData(true)]
+    [InlineData(false)]
+    public async Task FunctionArgumentTypesShouldBeRetainedIfSpecifiedAsync(bool retain)
+    {
+        // Arrange
+        using var responseMessage = new HttpResponseMessage(HttpStatusCode.OK)
+        {
+            Content = new StringContent(File.ReadAllText("TestData/chat_completion_multiple_function_calls_test_response.json"))
+        };
+
+        using HttpMessageHandlerStub handler = new();
+        handler.ResponseToReturn = responseMessage;
+        using HttpClient client = new(handler);
+
+        var clientCore = new ClientCore("modelId", "apikey", httpClient: client);
+
+        ChatHistory chatHistory = [];
+        chatHistory.Add(new ChatMessageContent(AuthorRole.User, "Hello"));
+
+        var settings = new OpenAIPromptExecutionSettings()
+        {
+            FunctionChoiceBehavior = FunctionChoiceBehavior.Auto(
+                autoInvoke: false,
+                options: new FunctionChoiceBehaviorOptions
+                {
+                    RetainArgumentTypes = retain
+                })
+        };
+
+        // Act
+        var result = await clientCore.GetChatMessageContentsAsync("gpt-4", chatHistory, settings, new Kernel());
+
+        // Assert
+        var functionCalls = FunctionCallContent.GetFunctionCalls(result.Single()).ToArray();
+        Assert.NotEmpty(functionCalls);
+
+        var getCurrentWeatherFunctionCall = functionCalls.FirstOrDefault(call => call.FunctionName == "GetCurrentWeather");
+        Assert.NotNull(getCurrentWeatherFunctionCall);
+
+        var intArgumentsFunctionCall = functionCalls.FirstOrDefault(call => call.FunctionName == "IntArguments");
+        Assert.NotNull(intArgumentsFunctionCall);
+
+        if (retain)
+        {
+            var location = Assert.IsType<JsonElement>(getCurrentWeatherFunctionCall.Arguments?["location"]);
+            Assert.Equal(JsonValueKind.String, location.ValueKind);
+            Assert.Equal("Boston, MA", location.ToString());
+
+            var age = Assert.IsType<JsonElement>(intArgumentsFunctionCall.Arguments?["age"]);
+            Assert.Equal(JsonValueKind.Number, age.ValueKind);
+            Assert.Equal(36, age.GetInt32());
+        }
+        else
+        {
+            var location = Assert.IsType<string>(getCurrentWeatherFunctionCall.Arguments?["location"]);
+            Assert.Equal("Boston, MA", location);
+
+            var age = Assert.IsType<string>(intArgumentsFunctionCall.Arguments?["age"]);
+            Assert.Equal("36", age);
+        }
+    }
+
     internal sealed class ChatMessageContentWithFunctionCalls : TheoryData<ChatMessageContent, bool>
     {
         private static readonly ChatToolCall s_functionCallWithInvalidFunctionName = ChatToolCall.CreateFunctionToolCall(id: "call123", functionName: "bar.foo", functionArguments: BinaryData.FromString("{}"));

dotnet/src/Connectors/Connectors.OpenAI/Core/ClientCore.ChatCompletion.cs

@@ -187,7 +187,7 @@ internal async Task<IReadOnlyList<ChatMessageContent>> GetChatMessageContentsAsy
                     throw;
                 }
 
-                chatMessageContent = this.CreateChatMessageContent(chatCompletion, targetModel);
+                chatMessageContent = this.CreateChatMessageContent(chatCompletion, targetModel, functionCallingConfig.Options?.RetainArgumentTypes ?? false);
                 activity?.SetCompletionResponse([chatMessageContent], chatCompletion.Usage.InputTokenCount, chatCompletion.Usage.OutputTokenCount);
             }
 
@@ -358,7 +358,7 @@ internal async IAsyncEnumerable<OpenAIStreamingChatMessageContent> GetStreamingC
                         ref toolCallIdsByIndex, ref functionNamesByIndex, ref functionArgumentBuildersByIndex);
 
                     // Translate all entries into FunctionCallContent instances for diagnostics purposes.
-                    functionCallContents = this.GetFunctionCallContents(toolCalls).ToArray();
+                    functionCallContents = this.GetFunctionCallContents(toolCalls, functionCallingConfig.Options?.RetainArgumentTypes ?? false).ToArray();
                 }
                 finally
                 {
@@ -887,11 +887,11 @@ private static ChatMessageContentPart GetImageContentItem(ImageContent imageCont
         return null;
     }
 
-    private OpenAIChatMessageContent CreateChatMessageContent(OpenAIChatCompletion completion, string targetModel)
+    private OpenAIChatMessageContent CreateChatMessageContent(OpenAIChatCompletion completion, string targetModel, bool retainArgumentTypes)
     {
         var message = new OpenAIChatMessageContent(completion, targetModel, this.GetChatCompletionMetadata(completion));
 
-        message.Items.AddRange(this.GetFunctionCallContents(completion.ToolCalls));
+        message.Items.AddRange(this.GetFunctionCallContents(completion.ToolCalls, retainArgumentTypes));
 
         return message;
     }
@@ -911,7 +911,7 @@ private OpenAIChatMessageContent CreateChatMessageContent(ChatMessageRole chatRo
         return message;
     }
 
-    private List<FunctionCallContent> GetFunctionCallContents(IEnumerable<ChatToolCall> toolCalls)
+    private List<FunctionCallContent> GetFunctionCallContents(IEnumerable<ChatToolCall> toolCalls, bool retainArgumentTypes)
     {
         List<FunctionCallContent> result = [];
 
@@ -926,7 +926,7 @@ private List<FunctionCallContent> GetFunctionCallContents(IEnumerable<ChatToolCa
                 try
                 {
                     arguments = JsonSerializer.Deserialize<KernelArguments>(toolCall.FunctionArguments);
-                    if (arguments is not null)
+                    if (arguments is { Count: > 0 } && !retainArgumentTypes)
                     {
                         // Iterate over copy of the names to avoid mutating the dictionary while enumerating it
                         var names = arguments.Names.ToArray();

dotnet/src/SemanticKernel.Abstractions/AI/ChatCompletion/AIFunctionKernelFunction.cs

@@ -78,7 +78,9 @@ private static IReadOnlyList<KernelParameterMetadata> MapParameterMetadata(AIFun
                 DefaultValue = param.Value.TryGetProperty("default", out JsonElement defaultValue) ? defaultValue : null,
                 IsRequired = param.Value.TryGetProperty("required", out JsonElement required) && required.GetBoolean(),
                 ParameterType = paramInfo?.ParameterType,
-                Schema = param.Value.TryGetProperty("schema", out JsonElement schema) ? new KernelJsonSchema(schema) : null,
+                Schema = param.Value.TryGetProperty("schema", out JsonElement schema)
+                    ? new KernelJsonSchema(schema)
+                    : new KernelJsonSchema(param.Value),
             });
         }
 

dotnet/src/SemanticKernel.Abstractions/AI/FunctionChoiceBehaviors/FunctionChoiceBehaviorOptions.cs

@@ -1,5 +1,7 @@
 // Copyright (c) Microsoft. All rights reserved.
 
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
 using System.Text.Json.Serialization;
 
 namespace Microsoft.SemanticKernel;
@@ -35,4 +37,14 @@ public sealed class FunctionChoiceBehaviorOptions
     /// </remarks>
     [JsonPropertyName("allow_strict_schema_adherence")]
     public bool AllowStrictSchemaAdherence { get; set; } = false;
+
+    /// <summary>
+    /// Gets or sets whether the types of function arguments provided by the AI model are retained by SK or not.
+    /// By default, or if set to false, SK will deserialize function arguments to strings, and type information will not be retained.
+    /// If set to true, function arguments will be deserialized as <see cref="System.Text.Json.JsonElement"/>, which retains type information.
+    /// </summary>
+    [JsonIgnore]
+    [Experimental("SKEXP0001")]
+    [EditorBrowsable(EditorBrowsableState.Never)]
+    public bool RetainArgumentTypes { get; set; } = false;
 }