Support POJO/Java Class for automatic responseSchema generation

[sunwon12]

Is your feature request related to a problem? Please describe.
I am frustrated when I have to manually define the responseSchema using complex builders, even though I already have well-structured DTO (Data Transfer Object) classes in my Java project.

Currently, the Java SDK requires developers to manually construct a Schema object. This leads to redundant work and high maintenance costs, as any change in the Java class must be manually reflected in the Schema builder. For example, in a project with many complex DTOs, this manual mapping is highly error-prone and degrades the Developer Experience (DX).

Describe the solution you'd like
I would like the GenerateContentConfig.Builder to support an overloaded responseSchema(Class<?> clazz) method. This method should automatically introspect the provided Java class (POJO/Record) and generate the corresponding Schema object.

Desired Usage:

// Instead of manual Schema building
GenerateContentConfig config = GenerateContentConfig.builder()
    .responseMimeType("application/json")
    .responseSchema(MyResponseDto.class) // Passing the DTO class directly
    .build();

The SDK should ideally use reflection or existing Jackson integration to map Java types (String, Integer, List, etc.) to the Gemini Type system.

Describe alternatives you've considered
I have considered the Python Gen AI SDK, which already provides this functionality through Pydantic models. Python developers can simply pass a class to response_schema, and the SDK handles the rest.

Currently, in Java, I have to write a custom utility using jsonschema-generator and map it back to the SDK's Schema object. This feels like a feature that should be natively supported to ensure "Feature Parity" across different language SDKs.

Additional context
Since the SDK already utilizes Jackson (@JsonProperty), implementing this wouldn't necessarily require heavy new dependencies. The implementation could respect Jackson annotations:

• @JsonPropertyDescription: To populate the description field in the schema.
• @JsonProperty: To handle custom field naming.

This enhancement would make the Java SDK feel much more "idiomatic" and productive for enterprise-level backend development.

[hemasekhar-p]

Hi @sunwon12 , Thank you for your feedback. We appreciate you taking the time to share your thoughts with us, and we'll be filing a feature request for this.

In the meantime, please use the below alternative approach to address your current requirements.

Create a Utility class.

package com.example.repros.jan2026;
import com.google.genai.types.Schema;
import com.google.genai.types.*;
import java.lang.reflect.Field;
import java.util.HashMap;
import java.util.Map;
import java.util.ArrayList;
import java.util.List;

public class PojoSchemaBridge {

    public static Schema fromClass(Class<?> clazz) {
        Schema.Builder schemaBuilder = Schema.builder().type(Type.Known.OBJECT);
        Map<String, Schema> properties = new HashMap<>();
        List<String> requiredFields = new ArrayList<>();

        for (Field field : clazz.getDeclaredFields()) {
            String fieldName = field.getName();
            Class<?> fieldType = field.getType();
       
            Schema propertySchema = mapType(fieldType);
            properties.put(fieldName, propertySchema);
            
            requiredFields.add(fieldName);
        }

        return schemaBuilder
                .properties(properties)
                .required(requiredFields)
                .build();
    }

    private static Schema mapType(Class<?> type) {
        if (type == String.class) {
            return Schema.builder().type(Type.Known.STRING).build();
        } else if (type == Integer.class || type == int.class) {
            return Schema.builder().type(Type.Known.INTEGER).build();
        } else if (type == Boolean.class || type == boolean.class) {
            return Schema.builder().type(Type.Known.BOOLEAN).build();
        } else if (List.class.isAssignableFrom(type)) {
            return Schema.builder()
                    .type(Type.Known.ARRAY)
                    .items(Schema.builder().type(Type.Known.STRING).build())
                    .build();
        }
        return Schema.builder().type(Type.Known.OBJECT).build();
    }
}

Create a DTO class

package com.example.repros.jan2026;
class TestDto {
    String name;
    int age;
    String place;
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public String getPlace() {
		return place;
	}
	public void setPlace(String place) {
		this.place = place;
	}
	@Override
	public String toString() {
		return "TestDto [name=" + name + ", age=" + age + ", place=" + place + "]";
	}	
    
}

Use the Utility class where ever you required

package com.example.repros.jan2026;

import com.google.genai.types.*;


public class SchemaSolution {
    public static void main(String[] args) {
      
    	Schema responseSchema = PojoSchemaBridge.fromClass(TestDto.class);
        GenerateContentConfig config = GenerateContentConfig.builder()
            .responseMimeType("application/json")
            .responseSchema(responseSchema) 
            .build();

        System.out.println("GenerateContentConfig Object: "+responseSchema.properties());
        
     
    }
}

[priyanahata]

Hi @sunwon12 we have a framework built on top of genai for this very purpose but with full out of the box pojo support and support for adding your own jacskon modules to serialize your own pojos to json, it currently works with the genai Schemas but in v2, we are doing both: Schemas and jsonSchemas.

https://github.com/anahata-os/gemini-java-client

It also adds the actual java type to the genai Schema using the "title" property so the model knows what is the exact java type of your pojos and all its fields, works pretty well even with nested tree (like a tree node) structures by putting a "recursive reference to xxxx for a type already listed in the schema"

Makes your pojos looks super clean, works for tool arguments and tool responses

@Getter
@Builder
@Schema(description = "Represents the detailed, multi-phase result of the MavenPom.addDependency tool.")
public class AddDependencyResult {

    @Schema(description = "Indicates if the initial pre-flight check to download the main artifact was successful.")
    private final boolean preflightCheckSuccess;

    @Schema(description = "Indicates if the pom.xml file was successfully modified.")
    private final boolean pomModificationSuccess;

    @Schema(description = "Contains the complete result of the 'dependency:resolve' Maven goal, including exit code, output, and a path to the full log file. This will be null if prior steps failed.")
    private final MavenBuildResult dependencyResolveResult;

    @Schema(description = "Indicates if the asynchronous background task to download sources and javadocs was launched.")
    private final boolean asyncDownloadsLaunched;

    @Schema(description = "A final, human-readable summary of the entire operation, intended for display.")
    private final String summary;
}

We also have a netbeans plugin if you want to test it on netbeans