.Net: fix: prevent duplicate "null" in JSON Schema type arrays for nullable parameters (#13635)

## Summary

- Fixes `InsertNullTypeIfRequired()` producing duplicate `"null"`
entries in JSON Schema type arrays (e.g., `["string", "null", "null"]`)
for `Nullable<T>` parameters with `= null` defaults
- Replaces reference-equality guard (`JsonArray.Contains()`) with
value-based `.Any()` check
- Adds 3 regression tests covering both trigger paths and positive
insertion

## Root Cause

`InsertNullTypeIfRequired()` in `OpenAIFunction.cs` uses
`jsonArray.Contains(NullType)` to check for existing `"null"` entries
before adding one. `JsonArray.Contains()` compares `JsonNode` objects by
reference equality — `JsonNode` does not override `Equals()`. The
`NullType` constant (`"null"`) creates a new `JsonNode` on implicit
conversion, so the guard always fails and `"null"` is always added as a
duplicate.

For `Nullable<T>` parameters with `= null` defaults,
`AIJsonUtilities.CreateJsonSchema()` correctly produces `["string",
"null"]`. The strict-mode sanitizer then attempts to add `"null"` again
— the broken guard lets it through, producing `["string", "null",
"null"]`.

Two trigger paths reach the same bug:
1. Optional parameters (`IsRequired = false`) → `insertNullType = true`
2. Schemas with `"nullable": true` keyword

## Changes

| File | Change |
|------|--------|
| `dotnet/src/Connectors/Connectors.OpenAI/Core/OpenAIFunction.cs` |
Replace `jsonArray.Contains(NullType)` with value-based `.Any()` check
(follows existing pattern in `NormalizeAdditionalProperties`) |
|
`dotnet/src/Connectors/Connectors.OpenAI.UnitTests/Core/OpenAIFunctionTests.cs`
| 3 new tests: duplicate prevention for optional params, duplicate
prevention for `nullable` keyword, positive case (null inserted when
absent) |

## Testing

- 3 new unit tests added covering:
- `ItDoesNotInsertDuplicateNullInTypeArrayForOptionalParameter` — schema
with pre-existing `["string", "null"]` + `IsRequired = false`
- `ItDoesNotInsertDuplicateNullInTypeArrayForNullableKeyword` — schema
with `"nullable": true` + `IsRequired = true`
- `ItInsertsNullInTypeArrayWhenAbsent` — schema with `["string"]` only →
`"null"` correctly added

Fixes #13527

---------

Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>
Co-authored-by: SergeyMenshykh <68852919+SergeyMenshykh@users.noreply.github.com>
Co-authored-by: SergeyMenshykh <sergemenshikh@gmail.com>
Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: 4 people

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

@@ -299,6 +299,72 @@ public void ItCleansUpRestrictedSchemaKeywords(string typeName, string keyword,
         }
     }
 
+    [Fact]
+    public void ItDoesNotInsertDuplicateNullInTypeArrayForOptionalParameter()
+    {
+        // Arrange — schema with type array already containing "null" (as AIJsonUtilities produces for Nullable<T>)
+        var parameterSchema = KernelJsonSchema.Parse("""{"type":["string","null"],"description":"A nullable param"}""");
+        OpenAIFunction f = KernelFunctionFactory.CreateFromMethod(
+            () => { },
+            parameters: [new KernelParameterMetadata("param1") { Description = "A nullable param", IsRequired = false, Schema = parameterSchema }]).Metadata.ToOpenAIFunction();
+
+        // Act
+        ChatTool result = f.ToFunctionDefinition(allowStrictSchemaAdherence: true);
+        ParametersData pd = JsonSerializer.Deserialize<ParametersData>(result.FunctionParameters.ToString())!;
+
+        // Assert
+        Assert.NotNull(pd.properties);
+        Assert.Single(pd.properties);
+        var expectedSchema = """{"type":["string","null"],"description":"A nullable param"}""";
+        Assert.Equal(
+            JsonSerializer.Serialize(KernelJsonSchema.Parse(expectedSchema)),
+            JsonSerializer.Serialize(pd.properties.First().Value.RootElement));
+    }
+
+    [Fact]
+    public void ItDoesNotInsertDuplicateNullInTypeArrayForNullableKeyword()
+    {
+        // Arrange — schema with "nullable": true and type array already containing "null"
+        var parameterSchema = KernelJsonSchema.Parse("""{"type":["string","null"],"nullable":true,"description":"A nullable param"}""");
+        OpenAIFunction f = KernelFunctionFactory.CreateFromMethod(
+            () => { },
+            parameters: [new KernelParameterMetadata("param1") { Description = "A nullable param", IsRequired = true, Schema = parameterSchema }]).Metadata.ToOpenAIFunction();
+
+        // Act
+        ChatTool result = f.ToFunctionDefinition(allowStrictSchemaAdherence: true);
+        ParametersData pd = JsonSerializer.Deserialize<ParametersData>(result.FunctionParameters.ToString())!;
+
+        // Assert — "nullable" keyword is removed in strict mode, type array should not gain duplicate "null"
+        Assert.NotNull(pd.properties);
+        Assert.Single(pd.properties);
+        var expectedSchema = """{"type":["string","null"],"description":"A nullable param"}""";
+        Assert.Equal(
+            JsonSerializer.Serialize(KernelJsonSchema.Parse(expectedSchema)),
+            JsonSerializer.Serialize(pd.properties.First().Value.RootElement));
+    }
+
+    [Fact]
+    public void ItInsertsNullInTypeArrayWhenAbsent()
+    {
+        // Arrange — schema with type array that does NOT contain "null"
+        var parameterSchema = KernelJsonSchema.Parse("""{"type":["string"],"description":"An optional param"}""");
+        OpenAIFunction f = KernelFunctionFactory.CreateFromMethod(
+            () => { },
+            parameters: [new KernelParameterMetadata("param1") { Description = "An optional param", IsRequired = false, Schema = parameterSchema }]).Metadata.ToOpenAIFunction();
+
+        // Act
+        ChatTool result = f.ToFunctionDefinition(allowStrictSchemaAdherence: true);
+        ParametersData pd = JsonSerializer.Deserialize<ParametersData>(result.FunctionParameters.ToString())!;
+
+        // Assert — "null" should be added to the type array
+        Assert.NotNull(pd.properties);
+        Assert.Single(pd.properties);
+        var expectedSchema = """{"type":["string","null"],"description":"An optional param"}""";
+        Assert.Equal(
+            JsonSerializer.Serialize(KernelJsonSchema.Parse(expectedSchema)),
+            JsonSerializer.Serialize(pd.properties.First().Value.RootElement));
+    }
+
 #pragma warning disable CA1812 // uninstantiated internal class
     private sealed class ParametersData
     {

dotnet/src/Connectors/Connectors.OpenAI/Core/OpenAIFunction.cs

@@ -313,7 +313,8 @@ private static void InsertNullTypeIfRequired(bool insertNullType, JsonObject jso
         {
             return;
         }
-        if (typeValue is JsonArray jsonArray && !jsonArray.Contains(NullType))
+        if (typeValue is JsonArray jsonArray &&
+            !jsonArray.Any(static x => x is JsonValue jv && jv.GetValueKind() == JsonValueKind.String && jv.GetValue<string>() == NullType))
         {
             jsonArray.Add(NullType);
         }