fix(vertexai): fix "Object of type 'FieldInfo' is not JSON serializable" across all schema generation (#1317)

## Description

Fixes "TypeError: Object of type 'FieldInfo' is not JSON serializable"
that occurred when using with_structured_output(..., method="json_mode")
with Pydantic v2 models containing Field metadata.

The issue occurred because model_json_schema() was called without the
mode parameter, causing Pydantic v2 to use validation mode which can
include non-serializable FieldInfo objects in certain contexts. Adding
mode='serialization' tells Pydantic to use its serialization schema
generation mode, which properly handles FieldInfo objects.

Using mode='serialization' is also semantically correct since the schema
describes the model's output format (what Gemini should generate), not
input validation rules.

Changes:
- Add mode='serialization' to model_json_schema() in chat_models.py:2562
- Add unit test for Pydantic v2 FieldInfo serialization
- Add unit test for Pydantic v1 backward compatibility
- Verify both Pydantic v1 (schema() method) and v2 paths work correctly

Backward compatibility:
- Pydantic v1 models: Continue using schema() method (line 2560)
- Pydantic v2 models: Now use model_json_schema(mode='serialization')
- No public API changes, fully backward compatible

## Relevant issues

<!-- e.g. "Fixes #000" -->

## Type

<!-- Select the type of Pull Request -->
<!-- Keep only the necessary ones -->

🆕 New Feature
🐛 Bug Fix
🧹 Refactoring
📖 Documentation
🚄 Infrastructure
✅ Test

## Changes(optional)

<!-- List of changes -->

## Testing(optional)

<!-- Test procedure -->
<!-- Test result -->

## Note(optional)

<!-- Information about the errors fixed by PR -->
<!-- Remaining issue or something -->
<!-- Other information about PR -->

Signed-off-by: jitokim <pigberger70@gmail.com>

Author: jitokim

libs/vertexai/langchain_google_vertexai/chains.py

@@ -48,7 +48,7 @@ def _create_structured_runnable_extra_step(
     prompt: BasePromptTemplate | None = None,
 ) -> Runnable:
     names = [
-        schema.model_json_schema()["title"]
+        schema.model_json_schema(mode="serialization")["title"]
         if hasattr(schema, "model_json_schema")
         else schema.schema()["title"]
         for schema in functions

libs/vertexai/langchain_google_vertexai/chat_models.py

@@ -2614,7 +2614,7 @@ class Explanation(BaseModel):
                 if issubclass(schema, BaseModelV1):
                     schema_json = schema.schema()
                 else:
-                    schema_json = schema.model_json_schema()  # type: ignore[attr-defined]
+                    schema_json = schema.model_json_schema(mode="serialization")  # type: ignore[attr-defined]
                 parser = PydanticOutputParser(pydantic_object=schema)
             else:
                 if is_typeddict(schema):

libs/vertexai/langchain_google_vertexai/functions_utils.py

@@ -192,7 +192,7 @@ def _format_base_tool_to_function_declaration(
         )
 
     if hasattr(tool.args_schema, "model_json_schema"):
-        schema = tool.args_schema.model_json_schema()
+        schema = tool.args_schema.model_json_schema(mode="serialization")
         pydantic_version = "v2"
     else:
         schema = tool.args_schema.schema()  # type: ignore[attr-defined]
@@ -211,7 +211,7 @@ def _format_pydantic_to_function_declaration(
     pydantic_model: type[BaseModel],
 ) -> gapic.FunctionDeclaration:
     if hasattr(pydantic_model, "model_json_schema"):
-        schema = pydantic_model.model_json_schema()
+        schema = pydantic_model.model_json_schema(mode="serialization")
         pydantic_version = "v2"
     else:
         schema = pydantic_model.schema()

libs/vertexai/tests/unit_tests/test_chat_models.py

@@ -1822,6 +1822,69 @@ def test_thinking_budget_in_invocation_params() -> None:
     assert invocation_params["include_thoughts"] is False
 
 
+def test_json_mode_with_pydantic_v2_fieldinfo_serialization() -> None:
+    """Test that json_mode uses serialization mode for Pydantic v2 model_json_schema.
+
+    This ensures that FieldInfo objects are properly serialized when generating
+    the JSON schema for structured output in json_mode. Using mode='serialization'
+    is semantically correct since the schema describes the model's output format,
+    not its input validation rules.
+    """
+    from pydantic import Field
+
+    class TestModel(BaseModel):
+        """Test model with Pydantic v2 FieldInfo metadata."""
+
+        name: str = Field(description="Person's name")
+        age: int = Field(gt=0, le=150, description="Person's age")
+
+    llm = ChatVertexAI(model_name="gemini-2.5-flash", project="test-project")
+
+    # This should not raise any errors when creating structured output
+    structured_llm = llm.with_structured_output(TestModel, method="json_mode")
+    assert structured_llm is not None
+
+    # Verify that model_json_schema works with mode='serialization'
+    schema = TestModel.model_json_schema(mode="serialization")
+    assert "properties" in schema
+    assert "name" in schema["properties"]
+    assert "age" in schema["properties"]
+    # Verify field metadata is preserved
+    assert "description" in schema["properties"]["name"]
+    assert schema["properties"]["name"]["description"] == "Person's name"
+
+
+def test_json_mode_pydantic_v1_backward_compatibility() -> None:
+    """Test that Pydantic v1 models continue to work with json_mode.
+
+    This ensures backward compatibility - Pydantic v1 models use schema()
+    method while v2 models use model_json_schema(mode='serialization').
+    """
+    from pydantic.v1 import BaseModel as BaseModelV1
+
+    class V1Model(BaseModelV1):
+        """Test model using Pydantic v1 API."""
+
+        name: str
+        age: int
+
+    llm = ChatVertexAI(model_name="gemini-2.5-flash", project="test-project")
+
+    # V1 models should work without issues
+    structured_llm = llm.with_structured_output(V1Model, method="json_mode")
+    assert structured_llm is not None
+
+    # Verify V1 model uses schema() method, not model_json_schema()
+    assert hasattr(V1Model, "schema")
+    assert not hasattr(V1Model, "model_json_schema")
+
+    # Verify schema generation works
+    schema = V1Model.schema()
+    assert "properties" in schema
+    assert "name" in schema["properties"]
+    assert "age" in schema["properties"]
+
+
 def test_thought_signature_conversion() -> None:
     # Test ReasoningContentBlock with signature
     reasoning_block = {