.Net: Function calling abstraction

dotnet/src/Connectors/Connectors.OpenAI/OpenAIPromptExecutionSettings.cs

@@ -294,6 +294,7 @@ public override PromptExecutionSettings Clone()
             ResponseFormat = this.ResponseFormat,
             TokenSelectionBiases = this.TokenSelectionBiases is not null ? new Dictionary<int, int>(this.TokenSelectionBiases) : null,
             ToolCallBehavior = this.ToolCallBehavior,
+            FunctionChoiceBehavior = this.FunctionChoiceBehavior,
             User = this.User,
             ChatSystemPrompt = this.ChatSystemPrompt
         };

dotnet/src/Functions/Functions.UnitTests/Markdown/Functions/KernelFunctionMarkdownTests.cs

@@ -1,5 +1,6 @@
 // Copyright (c) Microsoft. All rights reserved.
 
+using System.Linq;
 using Microsoft.SemanticKernel;
 using Xunit;
 
@@ -18,9 +19,56 @@ public void ItShouldCreatePromptFunctionConfigFromMarkdown()
         Assert.NotNull(model);
         Assert.Equal("TellMeAbout", model.Name);
         Assert.Equal("Hello AI, tell me about {{$input}}", model.Template);
-        Assert.Equal(2, model.ExecutionSettings.Count);
+        Assert.Equal(3, model.ExecutionSettings.Count);
         Assert.Equal("gpt4", model.ExecutionSettings["service1"].ModelId);
         Assert.Equal("gpt3.5", model.ExecutionSettings["service2"].ModelId);
+        Assert.Equal("gpt3.5-turbo", model.ExecutionSettings["service3"].ModelId);
+    }
+
+    [Fact]
+    public void ItShouldInitializeFunctionChoiceBehaviorsFromMarkdown()
+    {
+        // Arrange
+        var kernel = new Kernel();
+
+        // Act
+        var function = KernelFunctionMarkdown.CreateFromPromptMarkdown(Markdown, "TellMeAbout");
+
+        // Assert
+        Assert.NotNull(function);
+        Assert.NotEmpty(function.ExecutionSettings);
+
+        Assert.Equal(3, function.ExecutionSettings.Count);
+
+        // AutoFunctionCallChoice for service1
+        var service1ExecutionSettings = function.ExecutionSettings["service1"];
+        Assert.NotNull(service1ExecutionSettings);
+
+        var autoFunctionChoiceBehavior = service1ExecutionSettings.FunctionChoiceBehavior as AutoFunctionChoiceBehavior;
+        Assert.NotNull(autoFunctionChoiceBehavior);
+
+        Assert.NotNull(autoFunctionChoiceBehavior.Functions);
+        Assert.Single(autoFunctionChoiceBehavior.Functions);
+        Assert.Equal("p1.f1", autoFunctionChoiceBehavior.Functions.First());
+        Assert.Equal(8, autoFunctionChoiceBehavior.MaximumAutoInvokeAttempts);
+
+        // RequiredFunctionCallChoice for service2
+        var service2ExecutionSettings = function.ExecutionSettings["service2"];
+        Assert.NotNull(service2ExecutionSettings);
+
+        var requiredFunctionChoiceBehavior = service2ExecutionSettings.FunctionChoiceBehavior as RequiredFunctionChoiceBehavior;
+        Assert.NotNull(requiredFunctionChoiceBehavior);
+        Assert.NotNull(requiredFunctionChoiceBehavior.Functions);
+        Assert.Single(requiredFunctionChoiceBehavior.Functions);
+        Assert.Equal("p1.f1", requiredFunctionChoiceBehavior.Functions.First());
+        Assert.Equal(2, requiredFunctionChoiceBehavior.MaximumUseAttempts);
+
+        // NoneFunctionCallChoice for service3
+        var service3ExecutionSettings = function.ExecutionSettings["service3"];
+        Assert.NotNull(service3ExecutionSettings);
+
+        var noneFunctionChoiceBehavior = service3ExecutionSettings.FunctionChoiceBehavior as NoneFunctionChoiceBehavior;
+        Assert.NotNull(noneFunctionChoiceBehavior);
     }
 
     [Fact]
@@ -47,7 +95,12 @@ These are AI execution settings
         {
             "service1" : {
                 "model_id": "gpt4",
-                "temperature": 0.7
+                "temperature": 0.7,
+                "function_choice_behavior": {
+                    "type": "auto",
+                    "functions": ["p1.f1"],
+                    "maximumAutoInvokeAttempts": 8
+                }
             }
         }
         ```
@@ -56,7 +109,24 @@ These are more AI execution settings
         {
             "service2" : {
                 "model_id": "gpt3.5",
-                "temperature": 0.8
+                "temperature": 0.8,
+                "function_choice_behavior": {
+                    "type": "required",
+                    "functions": ["p1.f1"],
+                    "maximumUseAttempts": 2
+                }
+            }
+        }
+        ```
+        These are AI execution settings as well
+        ```sk.execution_settings
+        {
+            "service3" : {
+                "model_id": "gpt3.5-turbo",
+                "temperature": 0.8,
+                "function_choice_behavior": {
+                    "type": "none"
+                }
             }
         }
         ```

dotnet/src/Functions/Functions.UnitTests/Yaml/Functions/KernelFunctionYamlTests.cs

@@ -1,6 +1,7 @@
 // Copyright (c) Microsoft. All rights reserved.
 
 using System;
+using System.Linq;
 using Microsoft.SemanticKernel;
 using Microsoft.SemanticKernel.Connectors.OpenAI;
 using Xunit;
@@ -68,7 +69,7 @@ public void ItShouldSupportCreatingOpenAIExecutionSettings()
         // Arrange
         var deserializer = new DeserializerBuilder()
             .WithNamingConvention(UnderscoredNamingConvention.Instance)
-            .WithNodeDeserializer(new PromptExecutionSettingsNodeDeserializer())
+            .WithTypeConverter(new PromptExecutionSettingsTypeConverter())
             .Build();
         var promptFunctionModel = deserializer.Deserialize<PromptTemplateConfig>(this._yaml);
 
@@ -82,6 +83,40 @@ public void ItShouldSupportCreatingOpenAIExecutionSettings()
         Assert.Equal(0.0, executionSettings.TopP);
     }
 
+    [Fact]
+    public void ItShouldDeserializeFunctionChoiceBehaviors()
+    {
+        // Act
+        var promptTemplateConfig = KernelFunctionYaml.ToPromptTemplateConfig(this._yaml);
+
+        // Assert
+        Assert.NotNull(promptTemplateConfig?.ExecutionSettings);
+        Assert.Equal(3, promptTemplateConfig.ExecutionSettings.Count);
+
+        // Service with auto function choice behavior
+        var service1ExecutionSettings = promptTemplateConfig.ExecutionSettings["service1"];
+
+        var autoFunctionChoiceBehavior = service1ExecutionSettings.FunctionChoiceBehavior as AutoFunctionChoiceBehavior;
+        Assert.NotNull(autoFunctionChoiceBehavior?.Functions);
+        Assert.Equal("p1.f1", autoFunctionChoiceBehavior.Functions.Single());
+        Assert.Equal(9, autoFunctionChoiceBehavior.MaximumAutoInvokeAttempts);
+
+        // Service with required function choice behavior
+        var service2ExecutionSettings = promptTemplateConfig.ExecutionSettings["service2"];
+
+        var requiredFunctionChoiceBehavior = service2ExecutionSettings.FunctionChoiceBehavior as RequiredFunctionChoiceBehavior;
+        Assert.NotNull(requiredFunctionChoiceBehavior?.Functions);
+        Assert.Equal("p2.f2", requiredFunctionChoiceBehavior.Functions.Single());
+        Assert.Equal(6, requiredFunctionChoiceBehavior.MaximumAutoInvokeAttempts);
+        Assert.Equal(3, requiredFunctionChoiceBehavior.MaximumUseAttempts);
+
+        // Service with none function choice behavior
+        var service3ExecutionSettings = promptTemplateConfig.ExecutionSettings["service3"];
+
+        var noneFunctionChoiceBehavior = service3ExecutionSettings.FunctionChoiceBehavior as NoneFunctionChoiceBehavior;
+        Assert.NotNull(noneFunctionChoiceBehavior);
+    }
+
     [Fact]
     public void ItShouldCreateFunctionWithDefaultValueOfStringType()
     {
@@ -157,6 +192,11 @@ string CreateYaml(object defaultValue)
             frequency_penalty: 0.0
             max_tokens:        256
             stop_sequences:    []
+            function_choice_behavior:
+              type: auto
+              maximum_auto_invoke_attempts: 9
+              functions:
+              - p1.f1
           service2:
             model_id:          gpt-3.5
             temperature:       1.0
@@ -165,6 +205,22 @@ string CreateYaml(object defaultValue)
             frequency_penalty: 0.0
             max_tokens:        256
             stop_sequences:    [ "foo", "bar", "baz" ]
+            function_choice_behavior:
+              type: required
+              maximum_auto_invoke_attempts: 6
+              maximum_use_attempts: 3
+              functions:
+              - p2.f2
+          service3:
+            model_id:          gpt-3.5
+            temperature:       1.0
+            top_p:             0.0
+            presence_penalty:  0.0
+            frequency_penalty: 0.0
+            max_tokens:        256
+            stop_sequences:    [ "foo", "bar", "baz" ]
+            function_choice_behavior:
+              type: none
         """;
 
     private readonly string _yamlWithCustomSettings = """

dotnet/src/Functions/Functions.UnitTests/Yaml/PromptExecutionSettingsNodeDeserializerTests.cs → dotnet/src/Functions/Functions.UnitTests/Yaml/PromptExecutionSettingsTypeConverterTests.cs

@@ -8,17 +8,17 @@
 namespace SemanticKernel.Functions.UnitTests.Yaml;
 
 /// <summary>
-/// Tests for <see cref="PromptExecutionSettingsNodeDeserializer"/>.
+/// Tests for <see cref="PromptExecutionSettingsTypeConverter"/>.
 /// </summary>
-public sealed class PromptExecutionSettingsNodeDeserializerTests
+public sealed class PromptExecutionSettingsTypeConverterTests
 {
     [Fact]
     public void ItShouldCreatePromptFunctionFromYamlWithCustomModelSettings()
     {
         // Arrange
         var deserializer = new DeserializerBuilder()
             .WithNamingConvention(UnderscoredNamingConvention.Instance)
-            .WithNodeDeserializer(new PromptExecutionSettingsNodeDeserializer())
+            .WithTypeConverter(new PromptExecutionSettingsTypeConverter())
             .Build();
 
         // Act

dotnet/src/Functions/Functions.Yaml/KernelFunctionYaml.cs

@@ -57,7 +57,7 @@ public static PromptTemplateConfig ToPromptTemplateConfig(string text)
     {
         var deserializer = new DeserializerBuilder()
             .WithNamingConvention(UnderscoredNamingConvention.Instance)
-            .WithNodeDeserializer(new PromptExecutionSettingsNodeDeserializer())
+            .WithTypeConverter(new PromptExecutionSettingsTypeConverter())
             .Build();
 
         return deserializer.Deserialize<PromptTemplateConfig>(text);

dotnet/src/Functions/Functions.Yaml/PromptExecutionSettingsTypeConverter.cs

@@ -0,0 +1,73 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using System;
+using System.Collections.Generic;
+using YamlDotNet.Core;
+using YamlDotNet.Core.Events;
+using YamlDotNet.Serialization;
+using YamlDotNet.Serialization.NamingConventions;
+
+namespace Microsoft.SemanticKernel;
+
+/// <summary>
+/// Allows custom deserialization for <see cref="PromptExecutionSettings"/> from YAML prompts.
+/// </summary>
+internal sealed class PromptExecutionSettingsTypeConverter : IYamlTypeConverter
+{
+    private static IDeserializer? s_deserializer;
+
+    /// <inheritdoc/>
+    public bool Accepts(Type type)
+    {
+        return type == typeof(PromptExecutionSettings);
+    }
+
+    /// <inheritdoc/>
+    public object? ReadYaml(IParser parser, Type type)
+    {
+        s_deserializer ??= new DeserializerBuilder()
+            .WithNamingConvention(UnderscoredNamingConvention.Instance)
+            .IgnoreUnmatchedProperties() // Required to ignore the 'type' property used as type discrimination in the WithTypeDiscriminatingNodeDeserializer method below.
+                                         // Otherwise, the "Property '{name}' not found on type '{type.FullName}'" exception is thrown.
+            .WithTypeDiscriminatingNodeDeserializer((options) =>
+            {
+#pragma warning disable SKEXP0001
+                options.AddKeyValueTypeDiscriminator<FunctionChoiceBehavior>("type", new Dictionary<string, Type>
+                {
+                    { AutoFunctionChoiceBehavior.TypeDiscriminator, typeof(AutoFunctionChoiceBehavior) },
+                    { RequiredFunctionChoiceBehavior.TypeDiscriminator, typeof(RequiredFunctionChoiceBehavior) },
+                    { NoneFunctionChoiceBehavior.TypeDiscriminator, typeof(NoneFunctionChoiceBehavior) }
+                });
+#pragma warning restore SKEXP0010
+            })
+            .Build();
+
+        parser.MoveNext(); // Move to the first property  
+
+        var executionSettings = new PromptExecutionSettings();
+        while (parser.Current is not MappingEnd)
+        {
+            var propertyName = parser.Consume<Scalar>().Value;
+            switch (propertyName)
+            {
+                case "model_id":
+                    executionSettings.ModelId = s_deserializer.Deserialize<string>(parser);
+                    break;
+                case "function_choice_behavior":
+                    executionSettings.FunctionChoiceBehavior = s_deserializer.Deserialize<FunctionChoiceBehavior>(parser);
+                    break;
+                default:
+                    (executionSettings.ExtensionData ??= new Dictionary<string, object>()).Add(propertyName, s_deserializer.Deserialize<object>(parser));
+                    break;
+            }
+        }
+        parser.MoveNext(); // Move past the MappingEnd event  
+        return executionSettings;
+    }
+
+    /// <inheritdoc/>
+    public void WriteYaml(IEmitter emitter, object? value, Type type)
+    {
+        throw new NotImplementedException();
+    }
+}