fix: serialize raw bytes as base64 in A2A converters

ADK's A2A converters used Pydantic model_dump() in default mode, leaving raw
bytes (e.g. screenshots from computer_use) in the dict that is later placed
into a google.protobuf.Struct, which rejects non-JSON types and crashes with
ValueError: Unexpected type. Switch the converter model_dump calls to
mode="json" so bytes are base64-encoded to JSON-safe strings.
PiperOrigin-RevId: 951973549

Author: google-genai-bot

src/google/adk/a2a/converters/event_converter.py

@@ -91,7 +91,7 @@ def _serialize_metadata_value(value: Any) -> str:
   """
   if hasattr(value, "model_dump"):
     try:
-      return value.model_dump(exclude_none=True, by_alias=True)
+      return value.model_dump(mode="json", exclude_none=True, by_alias=True)
     except Exception as e:
       logger.warning("Failed to serialize metadata value: %s", e)
       return str(value)

src/google/adk/a2a/converters/part_converter.py

@@ -239,7 +239,9 @@ def apply_meta(p: a2a_types.Part, meta: dict[str, Any]) -> None:
     meta = {}
     if part.video_metadata:
       meta[_get_adk_metadata_key('video_metadata')] = (
-          part.video_metadata.model_dump(by_alias=True, exclude_none=True)
+          part.video_metadata.model_dump(
+              mode='json', by_alias=True, exclude_none=True
+          )
       )
     if part.part_metadata:
       meta.update(part.part_metadata)
@@ -274,7 +276,7 @@ def apply_meta(p: a2a_types.Part, meta: dict[str, Any]) -> None:
         ).decode('utf-8')
       if part.part_metadata:
         meta.update(part.part_metadata)
-      data_dict = val.model_dump(by_alias=True, exclude_none=True)
+      data_dict = val.model_dump(mode='json', by_alias=True, exclude_none=True)
       return _compat.make_data_part(data=data_dict, metadata=meta)
 
   logger.warning(

tests/unittests/a2a/converters/test_event_converter.py

@@ -35,6 +35,7 @@
 from google.adk.a2a.converters.utils import ADK_METADATA_KEY_PREFIX
 from google.adk.agents.invocation_context import InvocationContext
 from google.adk.events.event import Event
+from google.genai import types as genai_types
 import pytest
 
 
@@ -109,7 +110,7 @@ def test_serialize_metadata_value_with_model_dump(self):
 
     assert result == {"key": "value"}
     mock_value.model_dump.assert_called_once_with(
-        exclude_none=True, by_alias=True
+        mode="json", exclude_none=True, by_alias=True
     )
 
   def test_serialize_metadata_value_with_model_dump_exception(self):
@@ -131,6 +132,51 @@ def test_serialize_metadata_value_without_model_dump(self):
     result = _serialize_metadata_value(value)
     assert result == "simple_string"
 
+  def _serialized_metadata_with_bytes(self):
+    value = genai_types.FunctionResponse(
+        name="computer_use",
+        response={"inline_data": {"data": b"\x89PNG_BYTES"}},
+    )
+    result = _serialize_metadata_value(value)
+
+    # No raw bytes anywhere in the serialized structure.
+    def _assert_no_bytes(obj):
+      if isinstance(obj, bytes):
+        raise AssertionError("raw bytes leaked into serialized metadata")
+      if isinstance(obj, dict):
+        for v in obj.values():
+          _assert_no_bytes(v)
+      elif isinstance(obj, (list, tuple)):
+        for v in obj:
+          _assert_no_bytes(v)
+
+    _assert_no_bytes(result)
+    return result
+
+  @pytest.mark.skipif(
+      _compat.IS_A2A_V1, reason="0.3-only proto_utils.dict_to_struct"
+  )
+  def test_serialize_metadata_value_with_bytes_to_struct_v03(self):
+    """0.3: serialized metadata builds a proto Struct without raising."""
+    from a2a.utils import proto_utils
+
+    result = self._serialized_metadata_with_bytes()
+    struct = proto_utils.dict_to_struct({"meta": result})
+    assert struct is not None
+
+  @pytest.mark.skipif(
+      not _compat.IS_A2A_V1, reason="1.x-only ParseDict into proto Struct"
+  )
+  def test_serialize_metadata_value_with_bytes_to_struct_v1x(self):
+    """1.x: serialized metadata ParseDicts into a proto Struct."""
+    from google.protobuf import struct_pb2
+    from google.protobuf.json_format import ParseDict
+
+    result = self._serialized_metadata_with_bytes()
+    struct = struct_pb2.Struct()
+    ParseDict({"meta": result}, struct)
+    assert struct is not None
+
   def test_get_context_metadata_success(self):
     """Test successful context metadata creation."""
     result = _get_context_metadata(
@@ -601,7 +647,6 @@ def test_create_status_update_event_with_input_required_state(self):
   def test_convert_event_to_a2a_message_with_multiple_parts_returned(self):
     """Test event to message conversion when part_converter returns multiple parts."""
     from google.adk.a2a.converters.event_converter import convert_event_to_a2a_message
-    from google.genai import types as genai_types
 
     # Arrange
     mock_genai_part = genai_types.Part(text="source part")
@@ -815,7 +860,6 @@ def test_convert_a2a_task_to_event_message_conversion_error(self):
   def test_convert_a2a_message_to_event_success(self):
     """Test successful conversion of A2A message to event."""
     from google.adk.a2a.converters.event_converter import convert_a2a_message_to_event
-    from google.genai import types as genai_types
 
     # Use a real A2A part (production reads its metadata); the part_converter
     # callback is still mocked to return a canned genai Part.
@@ -844,7 +888,6 @@ def test_convert_a2a_message_to_event_success(self):
   def test_convert_a2a_message_to_event_with_multiple_parts_returned(self):
     """Test message to event conversion when part_converter returns multiple parts."""
     from google.adk.a2a.converters.event_converter import convert_a2a_message_to_event
-    from google.genai import types as genai_types
 
     # Arrange
     mock_a2a_part = _compat.make_text_part("part 1")
@@ -945,7 +988,6 @@ def test_convert_a2a_message_to_event_part_conversion_fails(self):
   def test_convert_a2a_message_to_event_part_conversion_exception(self):
     """Test handling when part conversion raises exception."""
     from google.adk.a2a.converters.event_converter import convert_a2a_message_to_event
-    from google.genai import types as genai_types
 
     # Setup mock to raise exception. The A2A parts are real (production
     # reads their metadata); the converter callback drives the behavior.

tests/unittests/a2a/converters/test_part_converter.py

@@ -1296,3 +1296,74 @@ def test_a2a_function_call_with_invalid_base64_thought_signature(self):
     assert result.function_call.name == "invalid_sig_tool"
     # thought_signature should be None due to decode failure
     assert result.thought_signature is None
+
+
+class TestBytesSerialization:
+  """Tests that raw bytes serialize as base64 through the A2A converters."""
+
+  def _function_response_with_bytes(self) -> genai_types.Part:
+    screenshot = b"\x89PNG\r\n\x1a\n_FAKE_SCREENSHOT_" + bytes(range(16))
+    function_response = genai_types.FunctionResponse(
+        name="computer_use",
+        response={
+            "screenshot": {"inline_data": {"data": screenshot}},
+            "status": "ok",
+        },
+    )
+    return genai_types.Part(function_response=function_response)
+
+  def _assert_bytes_serialized_as_base64_str(self, a2a_part):
+    assert a2a_part is not None
+    assert _compat.is_data_part(a2a_part)
+    # Raw bytes must be serialized to a base64 str, not kept as bytes.
+    data_dict = _compat.data_part_dict(a2a_part)
+    serialized = data_dict["response"]["screenshot"]["inline_data"]["data"]
+    assert isinstance(serialized, str)
+
+  @pytest.mark.skipif(_compat.IS_A2A_V1, reason="0.3-only proto_utils.ToProto")
+  def test_function_response_with_bytes_serializes_to_proto_struct_v03(self):
+    """0.3: the A2A DataPart serializes to a proto Struct without raising."""
+    from a2a.utils import proto_utils
+
+    a2a_part = convert_genai_part_to_a2a_part(
+        self._function_response_with_bytes()
+    )
+    self._assert_bytes_serialized_as_base64_str(a2a_part)
+
+    proto_part = proto_utils.ToProto.part(a2a_part)
+    assert proto_part is not None
+
+  @pytest.mark.skipif(
+      not _compat.IS_A2A_V1, reason="1.x-only proto Part / Struct"
+  )
+  def test_function_response_with_bytes_serializes_to_proto_struct_v1x(self):
+    """1.x: conversion builds the proto Struct in place (via ParseDict)."""
+    from google.protobuf import struct_pb2
+
+    a2a_part = convert_genai_part_to_a2a_part(
+        self._function_response_with_bytes()
+    )
+    self._assert_bytes_serialized_as_base64_str(a2a_part)
+
+    # The proto Struct build already happened during conversion; assert it.
+    assert a2a_part.WhichOneof("content") == "data"
+    assert isinstance(a2a_part.data, struct_pb2.Value)
+    assert a2a_part.data.HasField("struct_value")
+
+  def test_function_response_with_bytes_round_trip(self):
+    """genai -> a2a -> genai restores the original bytes losslessly."""
+    original = self._function_response_with_bytes()
+    a2a_part = convert_genai_part_to_a2a_part(original)
+    result = convert_a2a_part_to_genai_part(a2a_part)
+
+    assert result is not None
+    assert result.function_response is not None
+    restored = result.function_response.response["screenshot"]["inline_data"][
+        "data"
+    ]
+    expected = original.function_response.response["screenshot"]["inline_data"][
+        "data"
+    ]
+    if isinstance(restored, str):
+      restored = base64.b64decode(restored)
+    assert restored == expected