.Net: Function calling: Add function author role and name property - #3302

foreach (var message in chatHistory)
{
    var azureMessage = new ChatMessage(GetValidChatRole(message.Role), message.Content);
    string functionName = "";
    if (message.AdditionalContext?.TryGetValue("Name", out string? name) is true)
    {
        azureMessage.Name = name;
        functionName = name;
    }

    if (message.AdditionalContext?.TryGetValue("Arguments", out string? arguments) is true)
    {
        azureMessage.FunctionCall = new FunctionCall(functionName, arguments);
    }

    options.Messages.Add(azureMessage);
}

public static void AddAssistantMessage(this ChatHistory chatHistory, IChatResult chatResult)
{
    FunctionCall fc = chatResult.ModelResult.GetOpenAIChatResult().Choice.Message.FunctionCall;
    chatHistory.AddMessage(AuthorRole.Assistant, "", new Dictionary<string, string> {
        { "Name", fc.Name },
        { "Arguments", fc.Arguments }
    });
}

// Check for message response
var chatMessage = await chatResult.GetChatMessageAsync();
if (!string.IsNullOrEmpty(chatMessage.Content))
{
    Console.WriteLine(chatMessage.Content);

    // Add the response to chat history
    chatHistory.AddAssistantMessage(chatMessage.Content);
}
// Check for function response
OpenAIFunctionResponse? functionResponse = chatResult.GetFunctionResponse();
if (functionResponse is not null)
{
    chatHistory.AddAssistantMessage(chatResult);

foreach (var message in chatHistory)
{
    var azureMessage = new ChatMessage(new ChatRole(message.Role.Label), message.Content);
    string? functionName = null;

    if (message.AdditionalProperties?.TryGetValue("Name", out string? name) is true)
    {
        functionName = name;
    }

    if (message.AdditionalProperties?.TryGetValue("Arguments", out string? arguments) is true)
    {
        azureMessage.FunctionCall = new FunctionCall(functionName, arguments);
    } else
    {
        azureMessage.Name = functionName;
    }

    options.Messages.Add(azureMessage);
}

// Set FunctionCall to the name of a specific function to force the model to use that function.
requestSettings.FunctionCall = "TimePlugin-Date";
await CompleteChatWithFunctionsAsync("What day is today?", chatHistory, chatCompletion, kernel, requestSettings);

// Set FunctionCall to auto to let the model choose the best function to use.
requestSettings.FunctionCall = OpenAIRequestSettings.FunctionCallAuto;
await CompleteChatWithFunctionsAsync("What day is today and What computer tablets are available for under $200?", chatHistory, chatCompletion, kernel, requestSettings);

...

private static async Task CompleteChatWithFunctionsAsync(string ask, ChatHistory chatHistory, IChatCompletion chatCompletion, IKernel kernel, OpenAIRequestSettings requestSettings)
{
    Console.WriteLine($"User message: {ask}");
    chatHistory.AddUserMessage(ask);
    IChatResult chatResult;

    // Send request and add response to chat history
    chatResult = (await chatCompletion.GetChatCompletionsAsync(chatHistory, requestSettings))[0];
    chatHistory.AddAssistantMessage(chatResult);

    await PrintChatResultAsync(chatResult);
    do
    {
        // Check for function response
        OpenAIFunctionResponse? functionResponse = chatResult.GetFunctionResponse();
        if (functionResponse is not null)
        {
            // If the function returned by OpenAI is an SKFunction registered with the kernel,
            // you can invoke it using the following code.
            if (kernel.Functions.TryGetFunctionAndContext(functionResponse, out ISKFunction? func, out ContextVariables? context))
            {
                var result = (await kernel.RunAsync(func, context)).GetValue<object>();

                string? resultContent = null;
                if (result is RestApiOperationResponse apiResponse)
                {
                    resultContent = apiResponse.Content?.ToString();
                }
                else if (result is string str)
                {
                    resultContent = str;
                }

                if (!string.IsNullOrEmpty(resultContent))
                {
                    // Add the function result to chat history
                    chatHistory.AddFunctionMessage(resultContent, functionResponse.FullyQualifiedName);

                    //Get another completion
                    requestSettings.FunctionCall = OpenAIRequestSettings.FunctionCallAuto;
                    chatResult = (await chatCompletion.GetChatCompletionsAsync(chatHistory, requestSettings))[0];
                    chatHistory.AddAssistantMessage(chatResult);

                    await PrintChatResultAsync(chatResult);
                }
            }
            else
            {
                Console.WriteLine($"Error: Function {functionResponse.PluginName}.{functionResponse.FunctionName} not found.");
            }
        }
    } while (chatResult.ModelResult.GetOpenAIChatResult().Choice.FinishReason != CompletionsFinishReason.Stopped);
}