.Net: adds support for strict mode with OpenAI

dotnet/samples/Demos/OpenAIRealtime/Program.cs

@@ -70,7 +70,7 @@ public static async Task Main(string[] args)
         await session.AddItemAsync(
             ConversationItem.CreateUserMessage(["I'm trying to decide what to wear on my trip."]));
 
-        // Use audio file that contains a recorded question: "What's the weather like in San Francisco, California?" 
+        // Use audio file that contains a recorded question: "What's the weather like in San Francisco, California?"
         string inputAudioPath = FindFile("Assets\\realtime_whats_the_weather_pcm16_24khz_mono.wav");
         using Stream inputAudioStream = File.OpenRead(inputAudioPath);
 
@@ -165,7 +165,7 @@ await session.AddItemAsync(
                     var argumentsString = functionArgumentBuildersById[itemStreamingFinishedUpdate.ItemId].ToString();
                     var arguments = DeserializeArguments(argumentsString);
 
-                    // Create a function call content based on received data. 
+                    // Create a function call content based on received data.
                     var functionCallContent = new FunctionCallContent(
                         functionName: functionName,
                         pluginName: pluginName,
@@ -346,7 +346,7 @@ private static IEnumerable<ConversationTool> ConvertFunctions(Kernel kernel)
 
             foreach (var metadata in functionsMetadata)
             {
-                var toolDefinition = metadata.ToOpenAIFunction().ToFunctionDefinition();
+                var toolDefinition = metadata.ToOpenAIFunction().ToFunctionDefinition(false);
 
                 yield return new ConversationFunctionTool()
                 {

dotnet/src/Agents/OpenAI/Internal/AssistantThreadActions.cs

@@ -178,7 +178,7 @@ public static async IAsyncEnumerable<ChatMessageContent> GetMessagesAsync(Assist
 
         FunctionCallsProcessor functionProcessor = new(logger);
         // This matches current behavior.  Will be configurable upon integrating with `FunctionChoice` (#6795/#5200)
-        FunctionChoiceBehaviorOptions functionOptions = new() { AllowConcurrentInvocation = true, AllowParallelCalls = true };
+        FunctionChoiceBehaviorOptions functionOptions = new() { AllowConcurrentInvocation = true, AllowParallelCalls = true, AllowStrictSchemaAdherence = true };
 
         // Evaluate status and process steps and messages, as encountered.
         HashSet<string> processedStepIds = [];
@@ -412,7 +412,7 @@ public static async IAsyncEnumerable<StreamingChatMessageContent> InvokeStreamin
 
         FunctionCallsProcessor functionProcessor = new(logger);
         // This matches current behavior.  Will be configurable upon integrating with `FunctionChoice` (#6795/#5200)
-        FunctionChoiceBehaviorOptions functionOptions = new() { AllowConcurrentInvocation = true, AllowParallelCalls = true };
+        FunctionChoiceBehaviorOptions functionOptions = new() { AllowConcurrentInvocation = true, AllowParallelCalls = true, AllowStrictSchemaAdherence = true };
 
         IAsyncEnumerable<StreamingUpdate> asyncUpdates = client.CreateRunStreamingAsync(threadId, agent.Id, options, cancellationToken);
         do

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

@@ -1,5 +1,6 @@
 // Copyright (c) Microsoft. All rights reserved.
 
+using System;
 using System.Collections.Generic;
 using System.ComponentModel;
 using System.Linq;
@@ -45,35 +46,72 @@ public void ItInitializesOpenAIFunctionReturnParameterCorrectly(string? descript
         Assert.Same(schema, functionParameter.Schema);
     }
 
-    [Fact]
-    public void ItCanConvertToFunctionDefinitionWithNoPluginName()
+    [InlineData(true)]
+    [InlineData(false)]
+    [Theory]
+    public void ItCanConvertToFunctionDefinitionWithNoPluginName(bool strict)
     {
         // Arrange
         OpenAIFunction sut = KernelFunctionFactory.CreateFromMethod(() => { }, "myfunc", "This is a description of the function.").Metadata.ToOpenAIFunction();
 
         // Act
-        ChatTool result = sut.ToFunctionDefinition();
+        ChatTool result = sut.ToFunctionDefinition(strict);
 
         // Assert
         Assert.Equal(sut.FunctionName, result.FunctionName);
         Assert.Equal(sut.Description, result.FunctionDescription);
     }
 
-    [Fact]
-    public void ItCanConvertToFunctionDefinitionWithNullParameters()
+    [InlineData(true)]
+    [InlineData(false)]
+    [Theory]
+    public void ItCanConvertToFunctionDefinitionWithNullParameters(bool strict)
     {
-        // Arrange 
+        // Arrange
         OpenAIFunction sut = new("plugin", "function", "description", null, null);
 
         // Act
-        var result = sut.ToFunctionDefinition();
+        var result = sut.ToFunctionDefinition(strict);
 
         // Assert
-        Assert.Equal("{\"type\":\"object\",\"required\":[],\"properties\":{}}", result.FunctionParameters.ToString());
+        if (strict)
+        {
+            Assert.Equal("{\"type\":\"object\",\"required\":[],\"properties\":{},\"additionalProperties\":false}", result.FunctionParameters.ToString());
+        }
+        else
+        {
+            Assert.Equal("{\"type\":\"object\",\"required\":[],\"properties\":{}}", result.FunctionParameters.ToString());
+        }
+    }
+
+    [InlineData(false)]
+    [InlineData(true)]
+    [Theory]
+    public void SetsParametersToRequiredWhenStrict(bool strict)
+    {
+        var parameters = new List<OpenAIFunctionParameter>
+        {
+            new ("foo", "bar", false, typeof(string), null),
+        };
+        OpenAIFunction sut = new("plugin", "function", "description", parameters, null);
+
+        var result = sut.ToFunctionDefinition(strict);
+
+        Assert.Equal(strict, result.FunctionSchemaIsStrict);
+        if (strict)
+        {
+            Assert.Equal("""{"type":"object","required":["foo"],"properties":{"foo":{"description":"bar","type":["string","null"]}},"additionalProperties":false}""", result.FunctionParameters.ToString());
+        }
+        else
+        {
+            Assert.Equal("""{"type":"object","required":[],"properties":{"foo":{"description":"bar","type":"string"}}}""", result.FunctionParameters.ToString());
+        }
     }
 
-    [Fact]
-    public void ItCanConvertToFunctionDefinitionWithPluginName()
+    [InlineData(false)]
+    [InlineData(true)]
+    [Theory]
+    public void ItCanConvertToFunctionDefinitionWithPluginName(bool strict)
     {
         // Arrange
         OpenAIFunction sut = KernelPluginFactory.CreateFromFunctions("myplugin", new[]
@@ -82,17 +120,21 @@ public void ItCanConvertToFunctionDefinitionWithPluginName()
         }).GetFunctionsMetadata()[0].ToOpenAIFunction();
 
         // Act
-        ChatTool result = sut.ToFunctionDefinition();
+        ChatTool result = sut.ToFunctionDefinition(strict);
 
         // Assert
         Assert.Equal("myplugin-myfunc", result.FunctionName);
         Assert.Equal(sut.Description, result.FunctionDescription);
     }
 
-    [Fact]
-    public void ItCanConvertToFunctionDefinitionsWithParameterTypesAndReturnParameterType()
+    [InlineData(false)]
+    [InlineData(true)]
+    [Theory]
+    public void ItCanConvertToFunctionDefinitionsWithParameterTypesAndReturnParameterType(bool strict)
     {
-        string expectedParameterSchema = """{   "type": "object",   "required": ["param1", "param2"],   "properties": {     "param1": { "description": "String param 1", "type": "string" },     "param2": { "description": "Int param 2", "type": "integer" }   } } """;
+        string expectedParameterSchema = strict ?
+        """{   "type": "object",   "required": ["param1", "param2"],   "properties": {     "param1": { "description": "String param 1", "type": "string" },     "param2": { "description": "Int param 2", "type": "integer" }   },"additionalProperties":false } """ :
+        """{   "type": "object",   "required": ["param1", "param2"],   "properties": {     "param1": { "description": "String param 1", "type": "string" },     "param2": { "description": "Int param 2", "type": "integer" }   } } """;
 
         KernelPlugin plugin = KernelPluginFactory.CreateFromFunctions("Tests", new[]
         {
@@ -104,7 +146,7 @@ public void ItCanConvertToFunctionDefinitionsWithParameterTypesAndReturnParamete
 
         OpenAIFunction sut = plugin.GetFunctionsMetadata()[0].ToOpenAIFunction();
 
-        ChatTool functionDefinition = sut.ToFunctionDefinition();
+        ChatTool functionDefinition = sut.ToFunctionDefinition(strict);
 
         var exp = JsonSerializer.Serialize(KernelJsonSchema.Parse(expectedParameterSchema));
         var act = JsonSerializer.Serialize(KernelJsonSchema.Parse(functionDefinition.FunctionParameters));
@@ -115,10 +157,14 @@ public void ItCanConvertToFunctionDefinitionsWithParameterTypesAndReturnParamete
         Assert.Equal(JsonSerializer.Serialize(KernelJsonSchema.Parse(expectedParameterSchema)), JsonSerializer.Serialize(KernelJsonSchema.Parse(functionDefinition.FunctionParameters)));
     }
 
-    [Fact]
-    public void ItCanConvertToFunctionDefinitionsWithParameterTypesAndNoReturnParameterType()
+    [InlineData(false)]
+    [InlineData(true)]
+    [Theory]
+    public void ItCanConvertToFunctionDefinitionsWithParameterTypesAndNoReturnParameterType(bool strict)
     {
-        string expectedParameterSchema = """{   "type": "object",   "required": ["param1", "param2"],   "properties": {     "param1": { "description": "String param 1", "type": "string" },     "param2": { "description": "Int param 2", "type": "integer" }   } } """;
+        string expectedParameterSchema = strict ?
+        """{   "type": "object",   "required": ["param1", "param2"],   "properties": {     "param1": { "description": "String param 1", "type": "string" },     "param2": { "description": "Int param 2", "type": "integer" }   }, "additionalProperties":false} """ :
+        """{   "type": "object",   "required": ["param1", "param2"],   "properties": {     "param1": { "description": "String param 1", "type": "string" },     "param2": { "description": "Int param 2", "type": "integer" }   } } """;
 
         KernelPlugin plugin = KernelPluginFactory.CreateFromFunctions("Tests", new[]
         {
@@ -130,54 +176,129 @@ public void ItCanConvertToFunctionDefinitionsWithParameterTypesAndNoReturnParame
 
         OpenAIFunction sut = plugin.GetFunctionsMetadata()[0].ToOpenAIFunction();
 
-        ChatTool functionDefinition = sut.ToFunctionDefinition();
+        ChatTool functionDefinition = sut.ToFunctionDefinition(strict);
 
         Assert.NotNull(functionDefinition);
         Assert.Equal("Tests-TestFunction", functionDefinition.FunctionName);
         Assert.Equal("My test function", functionDefinition.FunctionDescription);
         Assert.Equal(JsonSerializer.Serialize(KernelJsonSchema.Parse(expectedParameterSchema)), JsonSerializer.Serialize(KernelJsonSchema.Parse(functionDefinition.FunctionParameters)));
     }
 
-    [Fact]
-    public void ItCanConvertToFunctionDefinitionsWithNoParameterTypes()
+    [InlineData(false)]
+    [InlineData(true)]
+    [Theory]
+    public void ItCanConvertToFunctionDefinitionsWithNoParameterTypes(bool strict)
     {
         // Arrange
         OpenAIFunction f = KernelFunctionFactory.CreateFromMethod(
             () => { },
             parameters: [new KernelParameterMetadata("param1")]).Metadata.ToOpenAIFunction();
 
         // Act
-        ChatTool result = f.ToFunctionDefinition();
+        ChatTool result = f.ToFunctionDefinition(strict);
         ParametersData pd = JsonSerializer.Deserialize<ParametersData>(result.FunctionParameters.ToString())!;
 
         // Assert
         Assert.NotNull(pd.properties);
         Assert.Single(pd.properties);
+        var expectedSchema = strict ?
+        """{ "type":["string","null"] }""" :
+        """{ "type":"string" }""";
         Assert.Equal(
-            JsonSerializer.Serialize(KernelJsonSchema.Parse("""{ "type":"string" }""")),
+            JsonSerializer.Serialize(KernelJsonSchema.Parse(expectedSchema)),
             JsonSerializer.Serialize(pd.properties.First().Value.RootElement));
     }
 
-    [Fact]
-    public void ItCanConvertToFunctionDefinitionsWithNoParameterTypesButWithDescriptions()
+    [InlineData(false)]
+    [InlineData(true)]
+    [Theory]
+    public void ItCanConvertToFunctionDefinitionsWithNoParameterTypesButWithDescriptions(bool strict)
     {
         // Arrange
         OpenAIFunction f = KernelFunctionFactory.CreateFromMethod(
             () => { },
             parameters: [new KernelParameterMetadata("param1") { Description = "something neat" }]).Metadata.ToOpenAIFunction();
 
         // Act
-        ChatTool result = f.ToFunctionDefinition();
+        ChatTool result = f.ToFunctionDefinition(strict);
         ParametersData pd = JsonSerializer.Deserialize<ParametersData>(result.FunctionParameters.ToString())!;
 
         // Assert
         Assert.NotNull(pd.properties);
         Assert.Single(pd.properties);
+        var expectedSchema = strict ?
+        """{ "description":"something neat", "type":["string","null"] }""" :
+        """{ "description":"something neat", "type":"string" }""";
         Assert.Equal(
-            JsonSerializer.Serialize(KernelJsonSchema.Parse("""{ "description":"something neat", "type":"string" }""")),
+            JsonSerializer.Serialize(KernelJsonSchema.Parse(expectedSchema)),
             JsonSerializer.Serialize(pd.properties.First().Value.RootElement));
     }
 
+    [InlineData("number", "maximum", "10", false)]
+    [InlineData("number", "maximum", "10", true)]
+    [InlineData("number", "minimum", "10", false)]
+    [InlineData("number", "minimum", "10", true)]
+    [InlineData("number", "maxContains", "10", false)]
+    [InlineData("number", "maxContains", "10", true)]
+    [InlineData("number", "minContains", "10", false)]
+    [InlineData("number", "minContains", "10", true)]
+    [InlineData("number", "multipleOf", "10", false)]
+    [InlineData("number", "multipleOf", "10", true)]
+    [InlineData("number", "format", "\"int64\"", false)]
+    [InlineData("number", "format", "\"int64\"", true)]
+    [InlineData("array", "maxItems", "5", false)]
+    [InlineData("array", "maxItems", "5", true)]
+    [InlineData("array", "minItems", "5", false)]
+    [InlineData("array", "minItems", "5", true)]
+    [InlineData("array", "contains", "5", false)]
+    [InlineData("array", "contains", "5", true)]
+    [InlineData("array", "uniqueItems", "true", false)]
+    [InlineData("array", "uniqueItems", "true", true)]
+    [InlineData("string", "minLength", "5", false)]
+    [InlineData("string", "minLength", "5", true)]
+    [InlineData("string", "maxLength", "5", false)]
+    [InlineData("string", "maxLength", "5", true)]
+    [InlineData("object", "maxProperties", "5", false)]
+    [InlineData("object", "maxProperties", "5", true)]
+    [InlineData("object", "minProperties", "5", false)]
+    [InlineData("object", "minProperties", "5", true)]
+    [InlineData("object", "pattern", "\"foo*\"", false)]
+    [InlineData("object", "pattern", "\"foo*\"", true)]
+    [InlineData("object", "patternProperties", "\"foo*\"", false)]
+    [InlineData("object", "patternProperties", "\"foo*\"", true)]
+    [InlineData("object", "propertyNames", """{ "maxLength": 3, "minLength": 3 }""", false)]
+    [InlineData("object", "propertyNames", """{ "maxLength": 3, "minLength": 3 }""", true)]
+    [InlineData("object", "unevaluatedItems", "true", false)]
+    [InlineData("object", "unevaluatedItems", "true", true)]
+    [InlineData("object", "unevaluatedProperties", "true", false)]
+    [InlineData("object", "unevaluatedProperties", "true", true)]
+    [Theory]
+    public void ItCleansUpRestrictedSchemaKeywords(string typeName, string keyword, string keywordValue, bool strict)
+    {
+        // Arrange
+        var parameterSchema = KernelJsonSchema.Parse($$"""{ "description":"something neat", "type":"{{typeName}}", "{{keyword}}":{{keywordValue}} }""");
+        OpenAIFunction f = KernelFunctionFactory.CreateFromMethod(
+            () => { },
+            parameters: [new KernelParameterMetadata("param1") { Description = "something neat", Schema = parameterSchema }]).Metadata.ToOpenAIFunction();
+
+        // Act
+        ChatTool result = f.ToFunctionDefinition(strict);
+        ParametersData pd = JsonSerializer.Deserialize<ParametersData>(result.FunctionParameters.ToString())!;
+
+        // Assert
+        Assert.NotNull(pd.properties);
+        Assert.Single(pd.properties);
+        var resultSchema = JsonSerializer.Serialize(pd.properties.First().Value.RootElement);
+        if (strict)
+        {
+            Assert.DoesNotContain(keyword, resultSchema, StringComparison.OrdinalIgnoreCase);
+        }
+        else
+        {
+            Assert.Contains(keyword, resultSchema, StringComparison.OrdinalIgnoreCase);
+        }
+    }
+
 #pragma warning disable CA1812 // uninstantiated internal class
     private sealed class ParametersData
     {