Address PR review: Use response_json_schema and simplify implementation

Key changes based on review feedback:
1. Switch from response_schema to response_json_schema
   - This bypasses Google SDK validation that rejected enhanced features for GLA
   - Enhanced features now work for BOTH GLA and Vertex AI!

2. Remove separate GLA/Vertex transformers
   - No longer needed since response_json_schema works everywhere
   - Reverted to single GoogleJsonSchemaTransformer
   - Removed prefer_inlined_defs and simplify_nullable_unions parameters

3. Simplify transformer implementation
   - Removed unnecessary comments and complexity
   - Removed Enhanced JSON Schema Support docs section (users don't need to know internal details)

4. Remove schema transformation tests
   - Deleted test_google_json_schema_features.py
   - Deleted test_google_discriminator.py
   - Removed test_gemini.py::test_json_def_recursive
   - These tested implementation details, not actual functionality
   - Existing test_google_model_structured_output provides adequate coverage

The root cause was using response_schema (old API) instead of response_json_schema (new API).
response_json_schema bypasses the restrictive validation and supports all enhanced features
for both GLA and Vertex AI.

Addresses review by @DouweM in PR #3357

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <[email protected]>

Author: conradlee

pydantic_ai_slim/pydantic_ai/models/google.py

@@ -267,7 +267,7 @@ async def count_tokens(
             messages, model_settings, model_request_parameters
         )
 
-        # Annoyingly, the type of `GenerateContentConfigDict.get` is "partially `Unknown`" because `response_schema` includes `typing._UnionGenericAlias`,
+        # Annoyingly, the type of `GenerateContentConfigDict.get` is "partially `Unknown`" because `response_json_schema` includes `typing._UnionGenericAlias`,
         # so without this we'd need `pyright: ignore[reportUnknownMemberType]` on every line and wouldn't get type checking anyway.
         generation_config = cast(dict[str, Any], generation_config)
 
@@ -291,7 +291,7 @@ async def count_tokens(
                     thinking_config=generation_config.get('thinking_config'),
                     media_resolution=generation_config.get('media_resolution'),
                     response_mime_type=generation_config.get('response_mime_type'),
-                    response_schema=generation_config.get('response_schema'),
+                    response_json_schema=generation_config.get('response_json_schema'),
                 ),
             )
 
@@ -455,7 +455,7 @@ async def _build_content_and_config(
             tools=cast(ToolListUnionDict, tools),
             tool_config=tool_config,
             response_mime_type=response_mime_type,
-            response_schema=response_schema,
+            response_json_schema=response_schema,
             response_modalities=modalities,
         )
         return contents, config

pydantic_ai_slim/pydantic_ai/profiles/google.py

@@ -5,75 +5,23 @@
 
 
 def google_model_profile(model_name: str) -> ModelProfile | None:
-    """Get the model profile for a Google model.
-
-    Note: This is a generic profile. For Google-specific providers, use:
-    - google_vertex_model_profile() for Vertex AI (supports enhanced JSON Schema)
-    - google_gla_model_profile() for Generative Language API (limited JSON Schema)
-    """
+    """Get the model profile for a Google model."""
     is_image_model = 'image' in model_name
     return ModelProfile(
-        json_schema_transformer=GoogleVertexJsonSchemaTransformer,
+        json_schema_transformer=GoogleJsonSchemaTransformer,
         supports_image_output=is_image_model,
         supports_json_schema_output=not is_image_model,
         supports_json_object_output=not is_image_model,
         supports_tools=not is_image_model,
     )
 
 
-def google_vertex_model_profile(model_name: str) -> ModelProfile | None:
-    """Get the model profile for a Google Vertex AI model.
-
-    Vertex AI supports enhanced JSON Schema features as of November 2025.
-    """
-    is_image_model = 'image' in model_name
-    return ModelProfile(
-        json_schema_transformer=GoogleVertexJsonSchemaTransformer,
-        supports_image_output=is_image_model,
-        supports_json_schema_output=not is_image_model,
-        supports_json_object_output=not is_image_model,
-        supports_tools=not is_image_model,
-    )
-
-
-def google_gla_model_profile(model_name: str) -> ModelProfile | None:
-    """Get the model profile for a Google Generative Language API model.
-
-    GLA has more limited JSON Schema support compared to Vertex AI.
-    """
-    is_image_model = 'image' in model_name
-    return ModelProfile(
-        json_schema_transformer=GoogleGLAJsonSchemaTransformer,
-        supports_image_output=is_image_model,
-        supports_json_schema_output=not is_image_model,
-        supports_json_object_output=not is_image_model,
-        supports_tools=not is_image_model,
-    )
-
-
-class GoogleVertexJsonSchemaTransformer(JsonSchemaTransformer):
-    """Transforms the JSON Schema from Pydantic to be suitable for Gemini via Vertex AI.
+class GoogleJsonSchemaTransformer(JsonSchemaTransformer):
+    """Transforms the JSON Schema from Pydantic to be suitable for Gemini.
 
     Gemini supports [a subset of OpenAPI v3.0.3](https://ai.google.dev/gemini-api/docs/function-calling#function_declarations).
-
-    As of November 2025, Gemini 2.5+ models via Vertex AI support enhanced JSON Schema features
-    (see [announcement](https://blog.google/technology/developers/gemini-api-structured-outputs/)) including:
-    * `title` for short property descriptions
-    * `anyOf` and `oneOf` for conditional structures (unions)
-    * `$ref` and `$defs` for recursive schemas and reusable definitions
-    * `minimum` and `maximum` for numeric constraints
-    * `additionalProperties` for dictionaries
-    * `type: 'null'` for optional fields
-    * `prefixItems` for tuple-like arrays
-
-    Not supported (empirically tested as of November 2025):
-    * `exclusiveMinimum` and `exclusiveMaximum` are not yet supported by the Google SDK
-    * `discriminator` field causes validation errors with nested oneOf schemas
     """
 
-    def __init__(self, schema: JsonSchema, *, strict: bool | None = None):
-        super().__init__(schema, strict=strict, prefer_inlined_defs=False, simplify_nullable_unions=True)
-
     def transform(self, schema: JsonSchema) -> JsonSchema:
         # Remove properties not supported by Gemini
         schema.pop('$schema', None)
@@ -97,77 +45,8 @@ def transform(self, schema: JsonSchema) -> JsonSchema:
             else:
                 schema['description'] = f'Format: {fmt}'
 
-        # As of November 2025, Gemini 2.5+ models via Vertex AI now support:
-        # - additionalProperties (for dict types)
-        # - $ref (for recursive schemas)
-        # - prefixItems (for tuple-like arrays)
-        # These are no longer stripped from the schema.
-
-        # Note: exclusiveMinimum/exclusiveMaximum are NOT yet supported by Google SDK,
-        # so we still need to strip them
+        # Note: exclusiveMinimum/exclusiveMaximum are NOT yet supported
         schema.pop('exclusiveMinimum', None)
         schema.pop('exclusiveMaximum', None)
 
         return schema
-
-
-class GoogleGLAJsonSchemaTransformer(JsonSchemaTransformer):
-    """Transforms the JSON Schema from Pydantic to be suitable for Gemini via Generative Language API.
-
-    The Generative Language API (google-gla) has MORE LIMITED JSON Schema support compared to Vertex AI.
-
-    Notably, GLA does NOT support (as of November 2025):
-    * `additionalProperties` - causes validation error
-    * `$ref` and `$defs` - must be inlined
-    * `prefixItems` - not supported
-    * `title` - stripped
-
-    This transformer applies more aggressive transformations to ensure compatibility with GLA.
-    """
-
-    def __init__(self, schema: JsonSchema, *, strict: bool | None = None):
-        # GLA requires $ref inlining
-        super().__init__(schema, strict=strict, prefer_inlined_defs=True, simplify_nullable_unions=True)
-
-    def transform(self, schema: JsonSchema) -> JsonSchema:
-        # Remove properties not supported by Gemini GLA
-        schema.pop('$schema', None)
-        if (const := schema.pop('const', None)) is not None:
-            # Gemini doesn't support const, but it does support enum with a single value
-            schema['enum'] = [const]
-        schema.pop('discriminator', None)
-        schema.pop('examples', None)
-
-        # GLA doesn't support title
-        schema.pop('title', None)
-
-        # Gemini only supports string enums
-        if enum := schema.get('enum'):
-            schema['type'] = 'string'
-            schema['enum'] = [str(val) for val in enum]
-
-        type_ = schema.get('type')
-        if type_ == 'string' and (fmt := schema.pop('format', None)):
-            description = schema.get('description')
-            if description:
-                schema['description'] = f'{description} (format: {fmt})'
-            else:
-                schema['description'] = f'Format: {fmt}'
-
-        # GLA does NOT support additionalProperties - must be stripped
-        if 'additionalProperties' in schema:
-            schema.pop('additionalProperties')
-
-        # GLA does NOT support prefixItems
-        if 'prefixItems' in schema:
-            schema.pop('prefixItems')
-
-        # Note: exclusiveMinimum/exclusiveMaximum are NOT supported
-        schema.pop('exclusiveMinimum', None)
-        schema.pop('exclusiveMaximum', None)
-
-        return schema
-
-
-# Backward compatibility alias
-GoogleJsonSchemaTransformer = GoogleVertexJsonSchemaTransformer

pydantic_ai_slim/pydantic_ai/providers/google_gla.py

@@ -8,7 +8,7 @@
 from pydantic_ai import ModelProfile
 from pydantic_ai.exceptions import UserError
 from pydantic_ai.models import cached_async_http_client
-from pydantic_ai.profiles.google import google_gla_model_profile
+from pydantic_ai.profiles.google import google_model_profile
 from pydantic_ai.providers import Provider
 
 
@@ -29,7 +29,7 @@ def client(self) -> httpx.AsyncClient:
         return self._client
 
     def model_profile(self, model_name: str) -> ModelProfile | None:
-        return google_gla_model_profile(model_name)
+        return google_model_profile(model_name)
 
     def __init__(self, api_key: str | None = None, http_client: httpx.AsyncClient | None = None) -> None:
         """Create a new Google GLA provider.

pydantic_ai_slim/pydantic_ai/providers/google_vertex.py

@@ -13,7 +13,7 @@
 from pydantic_ai import ModelProfile
 from pydantic_ai.exceptions import UserError
 from pydantic_ai.models import cached_async_http_client
-from pydantic_ai.profiles.google import google_vertex_model_profile
+from pydantic_ai.profiles.google import google_model_profile
 from pydantic_ai.providers import Provider
 
 try:
@@ -53,7 +53,7 @@ def client(self) -> httpx.AsyncClient:
         return self._client
 
     def model_profile(self, model_name: str) -> ModelProfile | None:
-        return google_vertex_model_profile(model_name)
+        return google_model_profile(model_name)
 
     @overload
     def __init__(

tests/models/test_gemini.py

@@ -444,57 +444,6 @@ class Locations(BaseModel):
     )
 
 
-async def test_json_def_recursive(allow_model_requests: None):
-    """Test that recursive schemas with $ref are now supported (as of November 2025)."""
-
-    class Location(BaseModel):
-        lat: float
-        lng: float
-        nested_locations: list[Location]
-
-    json_schema = Location.model_json_schema()
-    assert json_schema == snapshot(
-        {
-            '$defs': {
-                'Location': {
-                    'properties': {
-                        'lat': {'title': 'Lat', 'type': 'number'},
-                        'lng': {'title': 'Lng', 'type': 'number'},
-                        'nested_locations': {
-                            'items': {'$ref': '#/$defs/Location'},
-                            'title': 'Nested Locations',
-                            'type': 'array',
-                        },
-                    },
-                    'required': ['lat', 'lng', 'nested_locations'],
-                    'title': 'Location',
-                    'type': 'object',
-                }
-            },
-            '$ref': '#/$defs/Location',
-        }
-    )
-
-    m = GeminiModel('gemini-1.5-flash', provider=GoogleGLAProvider(api_key='via-arg'))
-    output_tool = ToolDefinition(
-        name='result',
-        description='This is the tool for the final Result',
-        parameters_json_schema=json_schema,
-    )
-    # As of November 2025, Gemini 2.5+ models support recursive $ref in JSON Schema
-    # This should no longer raise an error
-    mrp = ModelRequestParameters(
-        function_tools=[],
-        allow_text_output=True,
-        output_tools=[output_tool],
-        output_mode='text',
-        output_object=None,
-    )
-    mrp = m.customize_request_parameters(mrp)
-    # Verify the schema still contains $ref after customization
-    assert '$ref' in mrp.output_tools[0].parameters_json_schema
-
-
 async def test_json_def_date(allow_model_requests: None):
     class FormattedStringFields(BaseModel):
         d: datetime.date