.Net: Fix Google Gemini Enums Schema definition (#11617)

### Motivation and Context

- Fix #11395 

AIJsonUtilities Schema generation does not generate the `type` for
`enum` properties, this workaround became necessary to allow enums to be
used with VertexAI/GoogleAI API's.

FYI @eiriktsarpalis

Author: rogerbarreto

dotnet/samples/Concepts/ChatCompletion/Google_GeminiStructuredOutputs.cs

@@ -191,9 +191,26 @@ private struct Movie
 
         public bool IsAvailableOnStreaming { get; set; }
 
+        public MovieGenre? Genre { get; set; }
+
         public List<string> Tags { get; set; }
     }
 
+    private enum MovieGenre
+    {
+        Action,
+        Adventure,
+        Comedy,
+        Drama,
+        Fantasy,
+        Horror,
+        Mystery,
+        Romance,
+        SciFi,
+        Thriller,
+        Western
+    }
+
     private sealed class EmailResult
     {
         public List<Email> Emails { get; set; }
@@ -256,6 +273,7 @@ private void OutputResult(MovieResult movieResult)
                       Director: {movie.Director}
                       Release year: {movie.ReleaseYear}
                       Rating: {movie.Rating}
+                      Genre: {movie.Genre}
                       Is available on streaming: {movie.IsAvailableOnStreaming}
                       Tags: {string.Join(",", movie.Tags ?? [])}
                 """);

dotnet/src/Connectors/Connectors.Google.UnitTests/Core/Gemini/GeminiRequestTests.cs

@@ -584,6 +584,60 @@ public void ResponseSchemaConvertsNullableTypesToOpenApiFormat()
         Assert.True(ageProperty.GetProperty("nullable").GetBoolean());
     }
 
+    [Fact]
+    public void ResponseSchemaAddsTypeToEnumProperties()
+    {
+        // Arrange
+        var prompt = "prompt-example";
+        var schemaWithEnum = """
+            {
+                "properties" : {
+                    "Movies": {
+                        "type" : "array",
+                        "items" : {
+                            "type" : "object",
+                            "properties" : {
+                                "status": {
+                                    "enum": ["active", "inactive", null],
+                                    "description": "user status"
+                                },
+                                "role": {
+                                    "enum": ["admin", "user"],
+                                    "description": "user role"
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            """;
+
+        var executionSettings = new GeminiPromptExecutionSettings
+        {
+            ResponseMimeType = "application/json",
+            ResponseSchema = JsonSerializer.Deserialize<JsonElement>(schemaWithEnum)
+        };
+
+        // Act
+        var request = GeminiRequest.FromPromptAndExecutionSettings(prompt, executionSettings);
+
+        // Assert
+        Assert.NotNull(request.Configuration?.ResponseSchema);
+        var properties = request.Configuration.ResponseSchema.Value
+            .GetProperty("properties")
+            .GetProperty("Movies")
+            .GetProperty("items")
+            .GetProperty("properties");
+
+        var statusProperty = properties.GetProperty("status");
+        Assert.Equal("string", statusProperty.GetProperty("type").GetString());
+        Assert.Equal(3, statusProperty.GetProperty("enum").GetArrayLength());
+
+        var roleProperty = properties.GetProperty("role");
+        Assert.Equal("string", roleProperty.GetProperty("type").GetString());
+        Assert.Equal(2, roleProperty.GetProperty("enum").GetArrayLength());
+    }
+
     private sealed class DummyContent(object? innerContent, string? modelId = null, IReadOnlyDictionary<string, object?>? metadata = null) :
         KernelContent(innerContent, modelId, metadata);
 

dotnet/src/Connectors/Connectors.Google/Core/Gemini/Models/GeminiRequest.cs

@@ -326,7 +326,7 @@ private static void AddConfiguration(GeminiPromptExecutionSettings executionSett
             _ => CreateSchema(responseSchemaSettings.GetType(), GetDefaultOptions())
         };
 
-        jsonElement = AdjustOpenApi3Nullables(jsonElement);
+        jsonElement = TransformToOpenApi3Schema(jsonElement);
         return jsonElement;
     }
 
@@ -343,37 +343,52 @@ private static void AddConfiguration(GeminiPromptExecutionSettings executionSett
     /// - Replaces the type array with a single type value
     /// - Adds "nullable": true as a property
     /// </remarks>
-    private static JsonElement AdjustOpenApi3Nullables(JsonElement jsonElement)
+    private static JsonElement TransformToOpenApi3Schema(JsonElement jsonElement)
     {
         JsonNode? node = JsonNode.Parse(jsonElement.GetRawText());
         if (node is JsonObject rootObject)
         {
-            AdjustOpenApi3Object(rootObject);
+            TransformOpenApi3Object(rootObject);
         }
 
         return JsonSerializer.SerializeToElement(node, GetDefaultOptions());
 
-        static void AdjustOpenApi3Object(JsonObject obj)
+        static void TransformOpenApi3Object(JsonObject obj)
         {
             if (obj.TryGetPropertyValue("properties", out JsonNode? propsNode) && propsNode is JsonObject properties)
             {
                 foreach (var property in properties)
                 {
                     if (property.Value is JsonObject propertyObj)
                     {
-                        if (propertyObj.TryGetPropertyValue("type", out JsonNode? typeNode) && typeNode is JsonArray typeArray)
+                        // Handle enum properties - add "type": "string" if missing
+                        if (propertyObj.TryGetPropertyValue("enum", out JsonNode? enumNode) && !propertyObj.ContainsKey("type"))
                         {
-                            var types = typeArray.Select(t => t?.GetValue<string>()).Where(t => t != null).ToList();
-                            if (types.Contains("null"))
+                            propertyObj["type"] = JsonValue.Create("string");
+                        }
+                        else if (propertyObj.TryGetPropertyValue("type", out JsonNode? typeNode))
+                        {
+                            if (typeNode is JsonArray typeArray)
+                            {
+                                var types = typeArray.Select(t => t?.GetValue<string>()).Where(t => t != null).ToList();
+                                if (types.Contains("null"))
+                                {
+                                    var mainType = types.First(t => t != "null");
+                                    propertyObj["type"] = JsonValue.Create(mainType);
+                                    propertyObj["nullable"] = JsonValue.Create(true);
+                                }
+                            }
+                            else if (typeNode is JsonValue typeValue && typeValue.GetValue<string>() == "array")
                             {
-                                var mainType = types.First(t => t != "null");
-                                propertyObj["type"] = JsonValue.Create(mainType);
-                                propertyObj["nullable"] = JsonValue.Create(true);
+                                if (propertyObj.TryGetPropertyValue("items", out JsonNode? itemsNode) && itemsNode is JsonObject itemsObj)
+                                {
+                                    TransformOpenApi3Object(itemsObj);
+                                }
                             }
                         }
 
                         // Recursively process nested objects
-                        AdjustOpenApi3Object(propertyObj);
+                        TransformOpenApi3Object(propertyObj);
                     }
                 }
             }