update json mode

Author: PHAN Xuan Quang

Example APIs/Controllers/GroundingController.cs

@@ -11,21 +11,17 @@ public class GroundingController : ControllerBase
         [HttpPost("GenerationWithGrounding")]
         public async Task<IActionResult> GenerateContentWithGrounding(string apiKey, string prompt)
         {
-            var generatorWithApiKey = new Generator(apiKey)
-                .IncludesGroundingDetailInResponse()
-                .IncludesSearchEntryPointInResponse();
+            var generatorWithApiKey = new Generator(apiKey);
 
             var apiRequest = new ApiRequestBuilder()
                 .WithPrompt(prompt)
-                .EnableGrounding()
-                .WithChatHistory(new List<ChatMessage>())
                 .WithDefaultGenerationConfig()
                 .DisableAllSafetySettings()
                 .Build();
 
             try
             {
-                var response = await generatorWithApiKey.GenerateContentAsync(apiRequest, Generator.GetLatestStableModelVersion());
+                var response = await generatorWithApiKey.GenerateContentAsync<ChatMessage>(apiRequest, Generator.GetLatestStableModelVersion());
                 return Ok(response);
             }
             catch (Exception ex)

Gemini.NET/API Models/API Request/GenerationConfig.cs

@@ -51,5 +51,8 @@ public class GenerationConfig
         /// </summary>
         [JsonProperty("responseMimeType")]
         public string ResponseMimeType { get; set; } = EnumHelper.GetDescription(Enums.ResponseMimeType.PlainText);
+
+        [JsonProperty("responseSchema")]
+        public ResponseSchema? ResponseSchema { get; set; }
     }
 }

Gemini.NET/API Models/API Request/ResponseSchema.cs

@@ -0,0 +1,29 @@
+using Newtonsoft.Json;
+
+namespace Models.Request
+{
+    public class ResponseSchema(string type)
+    {
+        [JsonProperty("type")]
+        public string Type { get; set; } = type;
+
+        [JsonProperty("properties")]
+        public Dictionary<string, ResponseSchema>? Properties { get; set; }
+
+        [JsonProperty("required")]
+        public List<string>? Required { get; set; }
+
+        [JsonProperty("items")]
+        public ResponseSchema? Items { get; set; }
+
+        [JsonProperty("enum")]
+        public List<string>? Enum { get; set; }
+
+        [JsonProperty("default")]
+        public object? Default { get; set; }
+
+        public ResponseSchema() : this("object")
+        {
+        }
+    }
+}

Gemini.NET/ApiRequestBuilder.cs

@@ -113,20 +113,25 @@ public ApiRequestBuilder DisableAllSafetySettings()
         /// Sets the default generation configuration for the API request.
         /// </summary>
         /// <param name="temperature">The sampling temperature to set.</param>
-        /// <param name="responseMimeType">The response MIME type to set.</param>
+        /// <param name="maxOutputTokens">The maximum number of tokens in the generated output.</param>
         /// <returns>The current instance of <see cref="ApiRequestBuilder"/>.</returns>
         /// <exception cref="ArgumentOutOfRangeException">Thrown when the temperature is out of the valid range (0.0 to 2.0).</exception>
-        public ApiRequestBuilder WithDefaultGenerationConfig(float temperature = 1, ResponseMimeType responseMimeType = ResponseMimeType.PlainText)
+        public ApiRequestBuilder WithDefaultGenerationConfig(float temperature = 1, int maxOutputTokens = 8192)
         {
             if (temperature < 0.0F || temperature > 2.0F)
             {
                 throw new ArgumentOutOfRangeException(nameof(temperature), "Temperature must be between 0.0 and 2.0.");
             }
 
+            if (maxOutputTokens < 1)
+            {
+                throw new ArgumentOutOfRangeException(nameof(maxOutputTokens), "Max output tokens must be greater than 0.");
+            }
+
             _config = new GenerationConfig
             {
                 Temperature = temperature,
-                ResponseMimeType = EnumHelper.GetDescription(responseMimeType),
+                MaxOutputTokens = maxOutputTokens
             };
 
             return this;

Gemini.NET/Generator.cs

@@ -192,8 +192,6 @@ public async Task<ModelResponse> GenerateContentAsync(ApiRequest request, ModelV
                         var dto = JsonHelper.AsObject<Models.Response.Success.ApiResponse>(responseData);
                         var groudingMetadata = dto.Candidates[0].GroundingMetadata;
 
-                        Console.WriteLine(responseData);
-
                         return new ModelResponse
                         {
                             Result = dto.Candidates[0].Content != null
@@ -233,6 +231,53 @@ public async Task<ModelResponse> GenerateContentAsync(ApiRequest request, ModelV
             }
         }
 
+        /// <summary>
+        /// Generates content based on the provided API request and returns the result as the specified type.
+        /// </summary>
+        /// <typeparam name="T">Type of the generated object </typeparam>
+        /// <param name="request"></param>
+        /// <param name="modelVersion"></param>
+        /// <returns></returns>
+        /// <exception cref="ArgumentNullException"></exception>
+        /// <exception cref="InvalidOperationException"></exception>
+        public async Task<T?> GenerateContentAsync<T>(ApiRequest request, ModelVersion modelVersion = ModelVersion.Gemini_15_Flash)
+        {
+            if (!Validator.SupportsJsonOutput(modelVersion))
+            {
+                throw new ArgumentNullException(nameof(request), "JSON output is not supported for this model version.");
+            }
+
+            if (request.Tools != null && request.Tools.Count > 0)
+            {
+                throw new InvalidOperationException("JSON output is not supported for Grounding.");
+            }
+
+            try
+            {
+                if (request.GenerationConfig == null)
+                {
+                    request.GenerationConfig = new GenerationConfig
+                    {
+                        ResponseMimeType = EnumHelper.GetDescription(ResponseMimeType.Json),
+                        ResponseSchema = OpenApiSchemaGenerator.AsOpenApiSchema<T>(),
+                    };
+                }
+                else
+                {
+                    request.GenerationConfig.ResponseMimeType = EnumHelper.GetDescription(ResponseMimeType.Json);
+                    request.GenerationConfig.ResponseSchema = OpenApiSchemaGenerator.AsOpenApiSchema<T>();
+                }
+
+                var response = await GenerateContentAsync(request, modelVersion);
+
+                return JsonHelper.AsObject<T>(response.Result);
+            }
+            catch (Exception ex)
+            {
+                throw new InvalidOperationException($"Failed to generate content: {ex.Message}", ex);
+            }
+        }
+
 
         /// <summary>
         /// Gets the latest stable model version of Gemini.

Gemini.NET/Helpers/JsonHelper.cs

@@ -15,7 +15,10 @@ public static class JsonHelper
         /// <returns>A JSON string representation of the object.</returns>
         public static string AsString<T>(T obj)
         {
-            return JsonConvert.SerializeObject(obj, Formatting.Indented);
+            return JsonConvert.SerializeObject(obj, Formatting.Indented, new JsonSerializerSettings
+            {
+                NullValueHandling = NullValueHandling.Ignore
+            });
         }
 
         /// <summary>

Gemini.NET/Helpers/OpenApiSchemaGenerator.cs

@@ -0,0 +1,122 @@
+using Models.Request;
+using System.Reflection;
+
+namespace Gemini.NET.Helpers
+{
+    public static class OpenApiSchemaGenerator
+    {
+        public static ResponseSchema AsOpenApiSchema<T>()
+        {
+            return ConvertToSchema(typeof(T), new HashSet<Type>());
+        }
+
+        private static ResponseSchema ConvertToSchema(Type type, HashSet<Type> processedTypes)
+        {
+            if (processedTypes.Contains(type))
+            {
+                return new ResponseSchema("object");
+            }
+            processedTypes.Add(type);
+
+            var schema = new ResponseSchema("object")
+            {
+                Properties = [],
+                Required = []
+            };
+
+            var properties = type.GetProperties(BindingFlags.Public | BindingFlags.Instance);
+            foreach (var prop in properties)
+            {
+                string propName = prop.Name;
+                Type propType = prop.PropertyType;
+                ResponseSchema propSchema;
+
+                // Xử lý đặc biệt cho SearchSuggestions
+                if (propName == "SearchSuggestions")
+                {
+                    propSchema = new ResponseSchema("string");
+                }
+                else
+                {
+                    // Lấy kiểu của property theo định nghĩa OpenAPI
+                    var (openApiType, itemsSchema, enumValues) = GetOpenApiType(propType, processedTypes);
+                    propSchema = new ResponseSchema(openApiType);
+
+                    if (enumValues != null)
+                    {
+                        propSchema.Enum = enumValues;
+                    }
+                    if (openApiType == "array" && itemsSchema != null)
+                    {
+                        propSchema.Items = itemsSchema;
+                    }
+                    // Nếu kiểu là object (không phải primitive hay string) thì tiến hành convert nested object
+                    if (openApiType == "object" && !propType.IsPrimitive && propType != typeof(string))
+                    {
+                        propSchema = ConvertToSchema(propType, processedTypes);
+                    }
+                }
+
+                // Nếu property được đánh dấu là required (ví dụ dùng RequiredMemberAttribute)
+                if (Attribute.IsDefined(prop, typeof(System.Runtime.CompilerServices.RequiredMemberAttribute)))
+                {
+                    schema.Required.Add(propName);
+                }
+                schema.Properties[propName] = propSchema;
+            }
+
+            if (schema.Required.Count == 0)
+            {
+                schema.Required = null;
+            }
+
+            if (schema.Properties.Count == 0)
+            {
+                schema.Properties = null;
+            }
+
+            return schema;
+        }
+
+        // Hàm trả về kiểu openapi, schema của items (nếu array) và danh sách enum nếu có
+        private static (string type, ResponseSchema? itemsSchema, List<string>? enumValues) GetOpenApiType(Type type, HashSet<Type> processedTypes)
+        {
+            List<string>? enumValues = null;
+            ResponseSchema? itemsSchema = null;
+
+            if (type.IsEnum)
+            {
+                enumValues = Enum.GetNames(type).ToList();
+                return ("string", null, enumValues);
+            }
+
+            if (type == typeof(string))
+                return ("string", null, null);
+            if (type == typeof(int) || type == typeof(long) || type == typeof(short) || type == typeof(sbyte))
+                return ("integer", null, null);
+            if (type == typeof(float) || type == typeof(double) || type == typeof(decimal))
+                return ("number", null, null);
+            if (type == typeof(bool))
+                return ("boolean", null, null);
+
+            if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(List<>))
+            {
+                var itemType = type.GetGenericArguments()[0];
+                var (itemOpenApiType, innerItemsSchema, innerEnumValues) = GetOpenApiType(itemType, processedTypes);
+                itemsSchema = new ResponseSchema(itemOpenApiType);
+                if (innerEnumValues != null)
+                {
+                    itemsSchema.Enum = innerEnumValues;
+                }
+                // Nếu item là object (và không phải primitive hay string) thì chuyển đổi nested object
+                if (itemOpenApiType == "object" && !itemType.IsPrimitive && itemType != typeof(string))
+                {
+                    itemsSchema = ConvertToSchema(itemType, processedTypes);
+                }
+                return ("array", itemsSchema, null);
+            }
+
+            return ("object", null, null);
+        }
+    }
+}