.Net: Bug: Gemini LLM returns 400 error when plugin input class contains objects (in an nullable array/list) that contain nullable properties (similar to #11675)

[JoschaMetze]

Describe the bug
When a class with an array of objects that contain nullable property (e.g. string? City) is used as an input parameter to a plugin method in a Gemini LLM function call, a 400 error is returned from the Gemini API. This error does not occur when the same property is defined as non-nullable (string Location).
This is a similar situation that has been resolved in ticket #11675 but this time it's not top level properties but nested in an array

To Reproduce
Steps to reproduce the behavior:

1. Define a plugin method that accepts a class with an array of objects that have nullable string property string? City.
2. Register the plugin with Semantic Kernel
3. Invoke a prompt using GeminiPromptExecutionSettings with ToolCallBehavior = AutoInvokeKernelFunctions.
4. Observe that the Gemini API returns a 400 error.

"tools": [
    {
      "functionDeclarations": [
        {
          "description": "Get the weather for a given location.",
          "name": "MyWeatherPlugin_GetWeather",
          "parameters": {
            "properties": {
              "request": {
                "properties": {
                  "Locations": {
                    "items": {
                      "properties": {
                        "City": {
                          "type": [
                            "string",
                            "null"
                          ]
                        },
                        "Country": {
                          "type": [
                            "string",
                            "null"
                          ]
                        }
                      },
                      "type": "object"
                    },
                    "nullable": true,
                    "type": "array"
                  }
                },
                "type": "object"
              }
            },
            "required": [
              "request"
            ],
            "type": "object"
          }
        }
      ]
    }
  ]

Expected behavior
The function should be successfully invoked, and Gemini should handle nullable fields in the schema without returning an error.
The issue is caused by the type definition "type": ["string", "null"]

Screenshots
N/A

Platform
Language: C#
Source: Microsoft.SemanticKernel 1.47, Microsoft.SemanticKernel.Connectors.Google 1.60.0-alpha
AI model: Gemini-2.5-flash
IDE: All
OS: Windows

Additional context

 public class WeatherLocation
 {
     public string? City { get; set; }
     public string? Country { get; set; }
 }

 public sealed class WeatherRequest
 {
     public WeatherLocation[]? Locations { get; set; }
 }

 public class MyWeatherPlugin
 {
     [KernelFunction]
     [Description("Get the weather for a given location.")]
     private string GetWeather(WeatherRequest request)
     {
         return $"The weather in {request?.Locations.First().City} is sunny.";
     }
 }

[OrbitAVI]

Following

[taimans-git]

I have the same issue

[AndresQuindtAxoft]

EDIT2: I'm not using Gemini connector, rather I use OpenAI api compatible URL for Google and OpenAI Client implementation

I'm experiencing the same issue but with a different cause, recursive/self-referencing structures:

public class MyFilter
{
    public MyFilter[] NestedFilters { get; set; }  // <-- This causes 400 error
    public string Condition { get; set; }
    public int? FieldId { get; set; }
    public string Operator { get; set; }
    public object Value { get; set; }
}

// Plugin function
[KernelFunction]
public async Task<string> ProcessData(MyFilter filter)
{
...
}

EDIT:

I've been trying to work arround, and I think that this happens not only for having nested hierarchy

I have this code where my plugin parameter is a QueryPluginFilter and gemini returns 400 error

/// <summary>
/// Main query structure that contains all filters and their logical relationships
/// </summary>
public class QueryPluginFilter
{
    [Description("List of atomic filter conditions")]
    public FilterAtom[] Atoms { get; set; }

    [Description("List of logical expressions that combine atoms or other expressions")]
    public FilterExpression[] Expressions { get; set; }

    [Description("ID of the root expression or atom that represents the complete query")]
    public int Root { get; set; }
}

/// <summary>
/// Represents a single filter condition (atomic filter)
/// </summary>
public class FilterAtom
{
    [Description("Unique identifier for this atom")]
    public int Id { get; set; }

    [Description("The column ID to filter on")]
    public int ColumnId { get; set; }

    [Description("Comparison operator")]
    [JsonConverter(typeof(JsonStringEnumConverter))]
    public RuleOperator Operator { get; set; }

    [Description("Value to compare against")]
    public JsonElement Value { get; set; }
}

/// <summary>
/// Represents a logical expression that combines multiple atoms or expressions
/// </summary>
public class FilterExpression
{
    [Description("Unique identifier for this expression")]
    public int Id { get; set; }

    [Description("Logical operator type")]
    [JsonConverter(typeof(JsonStringEnumConverter))]
    public RuleCondition Type { get; set; }

    [Description("List of atom or expression IDs that this expression combines")]
    public int[] Items { get; set; }
}

[taimans-git]

@JoschaMetze does it work when you define the string properties not as nullable, e.g. public string City { get; set; }?

I am experiencing the same issue that the type is ["string", "null"] in the api call send from semantic kernel even for non-nullable properties. This should then also be a problem for OpenAi-Models, because the properties are marked as optional, although they actually should be provided.

[AndresQuindtAxoft]

Found a workaround

Enabling nullables with #nullable enable and initializing my arrays as empty. Gemini worked.

#nullable enable
namespace AxCloud.Modules.Shared.Agents.QueryAgent.Plugins.Classes
{
    public class QueryPluginFilter
    {
        [Description("List of atomic filter conditions")]
        public FilterAtom[] Atoms { get; init; } = []; //Initialized properties

        [Description("List of logical expressions that combine atoms or other expressions")]
        public FilterExpression[] Expressions { get; init; } = [];

        [Description("ID of the root expression or atom that represents the complete query")]
        public int Root { get; set; }
    }
}

#nullable enable
namespace AxCloud.Modules.Shared.Agents.QueryAgent.Plugins.Classes
{
    public class FilterAtom
    {
        [Description("Unique identifier for this atom")]
        public int Id { get; set; }

        [Description("The column ID to filter on")]
        public int ColumnId { get; set; }

        [Description("Comparison operator")]
        [JsonConverter(typeof(JsonStringEnumConverter))]
        public RuleOperator Operator { get; set; }

        [Description("Value to compare against")]
        public JsonElement Value { get; set; }
    }
}

#nullable enable
namespace AxCloud.Modules.Shared.Agents.QueryAgent.Plugins.Classes
{
    public class FilterExpression
    {
        [Description("Unique identifier for this expression")]
        public int Id { get; set; }

        [Description("Logical operator type")]
        [JsonConverter(typeof(JsonStringEnumConverter))]
        public RuleCondition Type { get; set; }

        [Description("List of atom or expression IDs that this expression combines")]
        public int[] Items { get; init; } = [];
    }
}