diff --git a/src/google/adk/a2a/converters/part_converter.py b/src/google/adk/a2a/converters/part_converter.py index c47ac727..8dab1097 100644 --- a/src/google/adk/a2a/converters/part_converter.py +++ b/src/google/adk/a2a/converters/part_converter.py @@ -18,6 +18,7 @@ module containing utilities for conversion betwen A2A Part and Google GenAI Part from __future__ import annotations +import base64 import json import logging import sys @@ -43,8 +44,11 @@ from ...utils.feature_decorator import working_in_progress logger = logging.getLogger('google_adk.' + __name__) A2A_DATA_PART_METADATA_TYPE_KEY = 'type' +A2A_DATA_PART_METADATA_IS_LONG_RUNNING_KEY = 'is_long_running' A2A_DATA_PART_METADATA_TYPE_FUNCTION_CALL = 'function_call' A2A_DATA_PART_METADATA_TYPE_FUNCTION_RESPONSE = 'function_response' +A2A_DATA_PART_METADATA_TYPE_CODE_EXECUTION_RESULT = 'code_execution_result' +A2A_DATA_PART_METADATA_TYPE_EXECUTABLE_CODE = 'executable_code' @working_in_progress @@ -67,7 +71,8 @@ def convert_a2a_part_to_genai_part( elif isinstance(part.file, a2a_types.FileWithBytes): return genai_types.Part( inline_data=genai_types.Blob( - data=part.file.bytes.encode('utf-8'), mime_type=part.file.mimeType + data=base64.b64decode(part.file.bytes), + mime_type=part.file.mimeType, ) ) else: @@ -84,7 +89,11 @@ def convert_a2a_part_to_genai_part( # response. # TODO once A2A defined how to suervice such information, migrate below # logic accordinlgy - if part.metadata and A2A_DATA_PART_METADATA_TYPE_KEY in part.metadata: + if ( + part.metadata + and _get_adk_metadata_key(A2A_DATA_PART_METADATA_TYPE_KEY) + in part.metadata + ): if ( part.metadata[_get_adk_metadata_key(A2A_DATA_PART_METADATA_TYPE_KEY)] == A2A_DATA_PART_METADATA_TYPE_FUNCTION_CALL @@ -103,6 +112,24 @@ def convert_a2a_part_to_genai_part( part.data, by_alias=True ) ) + if ( + part.metadata[_get_adk_metadata_key(A2A_DATA_PART_METADATA_TYPE_KEY)] + == A2A_DATA_PART_METADATA_TYPE_CODE_EXECUTION_RESULT + ): + return genai_types.Part( + code_execution_result=genai_types.CodeExecutionResult.model_validate( + part.data, by_alias=True + ) + ) + if ( + part.metadata[_get_adk_metadata_key(A2A_DATA_PART_METADATA_TYPE_KEY)] + == A2A_DATA_PART_METADATA_TYPE_EXECUTABLE_CODE + ): + return genai_types.Part( + executable_code=genai_types.ExecutableCode.model_validate( + part.data, by_alias=True + ) + ) return genai_types.Part(text=json.dumps(part.data)) logger.warning( @@ -118,27 +145,40 @@ def convert_genai_part_to_a2a_part( part: genai_types.Part, ) -> Optional[a2a_types.Part]: """Convert a Google GenAI Part to an A2A Part.""" + if part.text: - return a2a_types.TextPart(text=part.text) + a2a_part = a2a_types.TextPart(text=part.text) + if part.thought is not None: + a2a_part.metadata = {_get_adk_metadata_key('thought'): part.thought} + return a2a_types.Part(root=a2a_part) if part.file_data: - return a2a_types.FilePart( - file=a2a_types.FileWithUri( - uri=part.file_data.file_uri, - mimeType=part.file_data.mime_type, + return a2a_types.Part( + root=a2a_types.FilePart( + file=a2a_types.FileWithUri( + uri=part.file_data.file_uri, + mimeType=part.file_data.mime_type, + ) ) ) if part.inline_data: - return a2a_types.Part( - root=a2a_types.FilePart( - file=a2a_types.FileWithBytes( - bytes=part.inline_data.data, - mimeType=part.inline_data.mime_type, - ) + a2a_part = a2a_types.FilePart( + file=a2a_types.FileWithBytes( + bytes=base64.b64encode(part.inline_data.data).decode('utf-8'), + mimeType=part.inline_data.mime_type, ) ) + if part.video_metadata: + a2a_part.metadata = { + _get_adk_metadata_key( + 'video_metadata' + ): part.video_metadata.model_dump(by_alias=True, exclude_none=True) + } + + return a2a_types.Part(root=a2a_part) + # Conver the funcall and function reponse to A2A DataPart. # This is mainly for converting human in the loop and auth request and # response. @@ -151,9 +191,9 @@ def convert_genai_part_to_a2a_part( by_alias=True, exclude_none=True ), metadata={ - A2A_DATA_PART_METADATA_TYPE_KEY: ( - A2A_DATA_PART_METADATA_TYPE_FUNCTION_CALL - ) + _get_adk_metadata_key( + A2A_DATA_PART_METADATA_TYPE_KEY + ): A2A_DATA_PART_METADATA_TYPE_FUNCTION_CALL }, ) ) @@ -165,9 +205,37 @@ def convert_genai_part_to_a2a_part( by_alias=True, exclude_none=True ), metadata={ - A2A_DATA_PART_METADATA_TYPE_KEY: ( - A2A_DATA_PART_METADATA_TYPE_FUNCTION_RESPONSE - ) + _get_adk_metadata_key( + A2A_DATA_PART_METADATA_TYPE_KEY + ): A2A_DATA_PART_METADATA_TYPE_FUNCTION_RESPONSE + }, + ) + ) + + if part.code_execution_result: + return a2a_types.Part( + root=a2a_types.DataPart( + data=part.code_execution_result.model_dump( + by_alias=True, exclude_none=True + ), + metadata={ + _get_adk_metadata_key( + A2A_DATA_PART_METADATA_TYPE_KEY + ): A2A_DATA_PART_METADATA_TYPE_CODE_EXECUTION_RESULT + }, + ) + ) + + if part.executable_code: + return a2a_types.Part( + root=a2a_types.DataPart( + data=part.executable_code.model_dump( + by_alias=True, exclude_none=True + ), + metadata={ + _get_adk_metadata_key( + A2A_DATA_PART_METADATA_TYPE_KEY + ): A2A_DATA_PART_METADATA_TYPE_EXECUTABLE_CODE }, ) ) diff --git a/tests/unittests/a2a/converters/test_part_converter.py b/tests/unittests/a2a/converters/test_part_converter.py index 4b9bd47c..1e8f0d4a 100644 --- a/tests/unittests/a2a/converters/test_part_converter.py +++ b/tests/unittests/a2a/converters/test_part_converter.py @@ -21,17 +21,20 @@ import pytest # Skip all tests in this module if Python version is less than 3.10 pytestmark = pytest.mark.skipif( - sys.version_info < (3, 10), reason="A2A tool requires Python 3.10+" + sys.version_info < (3, 10), reason="A2A requires Python 3.10+" ) # Import dependencies with version checking try: from a2a import types as a2a_types + from google.adk.a2a.converters.part_converter import A2A_DATA_PART_METADATA_TYPE_CODE_EXECUTION_RESULT + from google.adk.a2a.converters.part_converter import A2A_DATA_PART_METADATA_TYPE_EXECUTABLE_CODE from google.adk.a2a.converters.part_converter import A2A_DATA_PART_METADATA_TYPE_FUNCTION_CALL from google.adk.a2a.converters.part_converter import A2A_DATA_PART_METADATA_TYPE_FUNCTION_RESPONSE from google.adk.a2a.converters.part_converter import A2A_DATA_PART_METADATA_TYPE_KEY from google.adk.a2a.converters.part_converter import convert_a2a_part_to_genai_part from google.adk.a2a.converters.part_converter import convert_genai_part_to_a2a_part + from google.adk.a2a.converters.utils import _get_adk_metadata_key from google.genai import types as genai_types except ImportError as e: if sys.version_info < (3, 10): @@ -44,9 +47,12 @@ except ImportError as e: genai_types = DummyTypes() A2A_DATA_PART_METADATA_TYPE_FUNCTION_CALL = "function_call" A2A_DATA_PART_METADATA_TYPE_FUNCTION_RESPONSE = "function_response" + A2A_DATA_PART_METADATA_TYPE_CODE_EXECUTION_RESULT = "code_execution_result" + A2A_DATA_PART_METADATA_TYPE_EXECUTABLE_CODE = "executable_code" A2A_DATA_PART_METADATA_TYPE_KEY = "type" convert_a2a_part_to_genai_part = lambda x: None convert_genai_part_to_a2a_part = lambda x: None + _get_adk_metadata_key = lambda x: f"adk_{x}" else: raise e @@ -92,11 +98,14 @@ class TestConvertA2aPartToGenaiPart: """Test conversion of A2A FilePart with bytes to GenAI Part.""" # Arrange test_bytes = b"test file content" - # Note: A2A FileWithBytes converts bytes to string automatically + # A2A FileWithBytes expects base64-encoded string + import base64 + + base64_encoded = base64.b64encode(test_bytes).decode("utf-8") a2a_part = a2a_types.Part( root=a2a_types.FilePart( file=a2a_types.FileWithBytes( - bytes=test_bytes, mimeType="text/plain" + bytes=base64_encoded, mimeType="text/plain" ) ) ) @@ -108,7 +117,7 @@ class TestConvertA2aPartToGenaiPart: assert result is not None assert isinstance(result, genai_types.Part) assert result.inline_data is not None - # Source code now properly converts A2A string back to bytes for GenAI Blob + # The converter decodes base64 back to original bytes assert result.inline_data.data == test_bytes assert result.inline_data.mime_type == "text/plain" @@ -123,9 +132,9 @@ class TestConvertA2aPartToGenaiPart: root=a2a_types.DataPart( data=function_call_data, metadata={ - A2A_DATA_PART_METADATA_TYPE_KEY: ( - A2A_DATA_PART_METADATA_TYPE_FUNCTION_CALL - ), + _get_adk_metadata_key( + A2A_DATA_PART_METADATA_TYPE_KEY + ): A2A_DATA_PART_METADATA_TYPE_FUNCTION_CALL, "adk_type": A2A_DATA_PART_METADATA_TYPE_FUNCTION_CALL, }, ) @@ -152,9 +161,9 @@ class TestConvertA2aPartToGenaiPart: root=a2a_types.DataPart( data=function_response_data, metadata={ - A2A_DATA_PART_METADATA_TYPE_KEY: ( - A2A_DATA_PART_METADATA_TYPE_FUNCTION_RESPONSE - ), + _get_adk_metadata_key( + A2A_DATA_PART_METADATA_TYPE_KEY + ): A2A_DATA_PART_METADATA_TYPE_FUNCTION_RESPONSE, "adk_type": A2A_DATA_PART_METADATA_TYPE_FUNCTION_RESPONSE, }, ) @@ -260,8 +269,25 @@ class TestConvertGenaiPartToA2aPart: # Assert assert result is not None - assert isinstance(result, a2a_types.TextPart) - assert result.text == "Hello, world!" + assert isinstance(result, a2a_types.Part) + assert isinstance(result.root, a2a_types.TextPart) + assert result.root.text == "Hello, world!" + + def test_convert_text_part_with_thought(self): + """Test conversion of GenAI text Part with thought to A2A Part.""" + # Arrange - thought is a boolean field in genai_types.Part + genai_part = genai_types.Part(text="Hello, world!", thought=True) + + # Act + result = convert_genai_part_to_a2a_part(genai_part) + + # Assert + assert result is not None + assert isinstance(result, a2a_types.Part) + assert isinstance(result.root, a2a_types.TextPart) + assert result.root.text == "Hello, world!" + assert result.root.metadata is not None + assert result.root.metadata[_get_adk_metadata_key("thought")] == True def test_convert_file_data_part(self): """Test conversion of GenAI file_data Part to A2A Part.""" @@ -277,10 +303,11 @@ class TestConvertGenaiPartToA2aPart: # Assert assert result is not None - assert isinstance(result, a2a_types.FilePart) - assert isinstance(result.file, a2a_types.FileWithUri) - assert result.file.uri == "gs://bucket/file.txt" - assert result.file.mimeType == "text/plain" + assert isinstance(result, a2a_types.Part) + assert isinstance(result.root, a2a_types.FilePart) + assert isinstance(result.root.file, a2a_types.FileWithUri) + assert result.root.file.uri == "gs://bucket/file.txt" + assert result.root.file.mimeType == "text/plain" def test_convert_inline_data_part(self): """Test conversion of GenAI inline_data Part to A2A Part.""" @@ -298,10 +325,34 @@ class TestConvertGenaiPartToA2aPart: assert isinstance(result, a2a_types.Part) assert isinstance(result.root, a2a_types.FilePart) assert isinstance(result.root.file, a2a_types.FileWithBytes) - # A2A FileWithBytes stores bytes as strings - assert result.root.file.bytes == test_bytes.decode("utf-8") + # A2A FileWithBytes now stores base64-encoded bytes to ensure round-trip compatibility + import base64 + + expected_base64 = base64.b64encode(test_bytes).decode("utf-8") + assert result.root.file.bytes == expected_base64 assert result.root.file.mimeType == "text/plain" + def test_convert_inline_data_part_with_video_metadata(self): + """Test conversion of GenAI inline_data Part with video metadata to A2A Part.""" + # Arrange + test_bytes = b"test video content" + video_metadata = genai_types.VideoMetadata(fps=30.0) + genai_part = genai_types.Part( + inline_data=genai_types.Blob(data=test_bytes, mime_type="video/mp4"), + video_metadata=video_metadata, + ) + + # Act + result = convert_genai_part_to_a2a_part(genai_part) + + # Assert + assert result is not None + assert isinstance(result, a2a_types.Part) + assert isinstance(result.root, a2a_types.FilePart) + assert isinstance(result.root.file, a2a_types.FileWithBytes) + assert result.root.metadata is not None + assert _get_adk_metadata_key("video_metadata") in result.root.metadata + def test_convert_function_call_part(self): """Test conversion of GenAI function_call Part to A2A Part.""" # Arrange @@ -320,7 +371,9 @@ class TestConvertGenaiPartToA2aPart: expected_data = function_call.model_dump(by_alias=True, exclude_none=True) assert result.root.data == expected_data assert ( - result.root.metadata[A2A_DATA_PART_METADATA_TYPE_KEY] + result.root.metadata[ + _get_adk_metadata_key(A2A_DATA_PART_METADATA_TYPE_KEY) + ] == A2A_DATA_PART_METADATA_TYPE_FUNCTION_CALL ) @@ -344,10 +397,62 @@ class TestConvertGenaiPartToA2aPart: ) assert result.root.data == expected_data assert ( - result.root.metadata[A2A_DATA_PART_METADATA_TYPE_KEY] + result.root.metadata[ + _get_adk_metadata_key(A2A_DATA_PART_METADATA_TYPE_KEY) + ] == A2A_DATA_PART_METADATA_TYPE_FUNCTION_RESPONSE ) + def test_convert_code_execution_result_part(self): + """Test conversion of GenAI code_execution_result Part to A2A Part.""" + # Arrange + code_execution_result = genai_types.CodeExecutionResult( + outcome=genai_types.Outcome.OUTCOME_OK, output="Hello, World!" + ) + genai_part = genai_types.Part(code_execution_result=code_execution_result) + + # Act + result = convert_genai_part_to_a2a_part(genai_part) + + # Assert + assert result is not None + assert isinstance(result, a2a_types.Part) + assert isinstance(result.root, a2a_types.DataPart) + expected_data = code_execution_result.model_dump( + by_alias=True, exclude_none=True + ) + assert result.root.data == expected_data + assert ( + result.root.metadata[ + _get_adk_metadata_key(A2A_DATA_PART_METADATA_TYPE_KEY) + ] + == A2A_DATA_PART_METADATA_TYPE_CODE_EXECUTION_RESULT + ) + + def test_convert_executable_code_part(self): + """Test conversion of GenAI executable_code Part to A2A Part.""" + # Arrange + executable_code = genai_types.ExecutableCode( + language=genai_types.Language.PYTHON, code="print('Hello, World!')" + ) + genai_part = genai_types.Part(executable_code=executable_code) + + # Act + result = convert_genai_part_to_a2a_part(genai_part) + + # Assert + assert result is not None + assert isinstance(result, a2a_types.Part) + assert isinstance(result.root, a2a_types.DataPart) + expected_data = executable_code.model_dump(by_alias=True, exclude_none=True) + assert result.root.data == expected_data + assert ( + result.root.metadata[ + _get_adk_metadata_key(A2A_DATA_PART_METADATA_TYPE_KEY) + ] + == A2A_DATA_PART_METADATA_TYPE_EXECUTABLE_CODE + ) + def test_convert_unsupported_part(self): """Test handling of unsupported GenAI Part types.""" # Arrange - Create a GenAI Part with no recognized fields @@ -379,8 +484,9 @@ class TestRoundTripConversions: # Assert assert result_a2a_part is not None - assert isinstance(result_a2a_part, a2a_types.TextPart) - assert result_a2a_part.text == original_text + assert isinstance(result_a2a_part, a2a_types.Part) + assert isinstance(result_a2a_part.root, a2a_types.TextPart) + assert result_a2a_part.root.text == original_text def test_file_uri_round_trip(self): """Test round-trip conversion for file parts with URI.""" @@ -401,10 +507,122 @@ class TestRoundTripConversions: # Assert assert result_a2a_part is not None - assert isinstance(result_a2a_part, a2a_types.FilePart) - assert isinstance(result_a2a_part.file, a2a_types.FileWithUri) - assert result_a2a_part.file.uri == original_uri - assert result_a2a_part.file.mimeType == original_mime_type + assert isinstance(result_a2a_part, a2a_types.Part) + assert isinstance(result_a2a_part.root, a2a_types.FilePart) + assert isinstance(result_a2a_part.root.file, a2a_types.FileWithUri) + assert result_a2a_part.root.file.uri == original_uri + assert result_a2a_part.root.file.mimeType == original_mime_type + + def test_file_bytes_round_trip(self): + """Test round-trip conversion for file parts with bytes.""" + # Arrange + original_bytes = b"test file content for round trip" + original_mime_type = "application/octet-stream" + + # Start with GenAI part (the more common starting point) + genai_part = genai_types.Part( + inline_data=genai_types.Blob( + data=original_bytes, mime_type=original_mime_type + ) + ) + + # Act - Round trip: GenAI -> A2A -> GenAI + a2a_part = convert_genai_part_to_a2a_part(genai_part) + result_genai_part = convert_a2a_part_to_genai_part(a2a_part) + + # Assert + assert result_genai_part is not None + assert isinstance(result_genai_part, genai_types.Part) + assert result_genai_part.inline_data is not None + assert result_genai_part.inline_data.data == original_bytes + assert result_genai_part.inline_data.mime_type == original_mime_type + + def test_function_call_round_trip(self): + """Test round-trip conversion for function call parts.""" + # Arrange + function_call = genai_types.FunctionCall( + name="test_function", args={"param1": "value1", "param2": 42} + ) + genai_part = genai_types.Part(function_call=function_call) + + # Act - Round trip: GenAI -> A2A -> GenAI + a2a_part = convert_genai_part_to_a2a_part(genai_part) + result_genai_part = convert_a2a_part_to_genai_part(a2a_part) + + # Assert + assert result_genai_part is not None + assert isinstance(result_genai_part, genai_types.Part) + assert result_genai_part.function_call is not None + assert result_genai_part.function_call.name == function_call.name + assert result_genai_part.function_call.args == function_call.args + + def test_function_response_round_trip(self): + """Test round-trip conversion for function response parts.""" + # Arrange + function_response = genai_types.FunctionResponse( + name="test_function", response={"result": "success", "data": [1, 2, 3]} + ) + genai_part = genai_types.Part(function_response=function_response) + + # Act - Round trip: GenAI -> A2A -> GenAI + a2a_part = convert_genai_part_to_a2a_part(genai_part) + result_genai_part = convert_a2a_part_to_genai_part(a2a_part) + + # Assert + assert result_genai_part is not None + assert isinstance(result_genai_part, genai_types.Part) + assert result_genai_part.function_response is not None + assert result_genai_part.function_response.name == function_response.name + assert ( + result_genai_part.function_response.response + == function_response.response + ) + + def test_code_execution_result_round_trip(self): + """Test round-trip conversion for code execution result parts.""" + # Arrange + code_execution_result = genai_types.CodeExecutionResult( + outcome=genai_types.Outcome.OUTCOME_OK, output="Hello, World!" + ) + genai_part = genai_types.Part(code_execution_result=code_execution_result) + + # Act - Round trip: GenAI -> A2A -> GenAI + a2a_part = convert_genai_part_to_a2a_part(genai_part) + result_genai_part = convert_a2a_part_to_genai_part(a2a_part) + + # Assert + assert result_genai_part is not None + assert isinstance(result_genai_part, genai_types.Part) + assert result_genai_part.code_execution_result is not None + assert ( + result_genai_part.code_execution_result.outcome + == code_execution_result.outcome + ) + assert ( + result_genai_part.code_execution_result.output + == code_execution_result.output + ) + + def test_executable_code_round_trip(self): + """Test round-trip conversion for executable code parts.""" + # Arrange + executable_code = genai_types.ExecutableCode( + language=genai_types.Language.PYTHON, code="print('Hello, World!')" + ) + genai_part = genai_types.Part(executable_code=executable_code) + + # Act - Round trip: GenAI -> A2A -> GenAI + a2a_part = convert_genai_part_to_a2a_part(genai_part) + result_genai_part = convert_a2a_part_to_genai_part(a2a_part) + + # Assert + assert result_genai_part is not None + assert isinstance(result_genai_part, genai_types.Part) + assert result_genai_part.executable_code is not None + assert ( + result_genai_part.executable_code.language == executable_code.language + ) + assert result_genai_part.executable_code.code == executable_code.code class TestEdgeCases: @@ -468,3 +686,75 @@ class TestEdgeCases: # Assert assert result is not None assert result.text == json.dumps(data) + + +class TestNewConstants: + """Test cases for new constants and functionality.""" + + def test_new_constants_exist(self): + """Test that new constants are defined.""" + assert ( + A2A_DATA_PART_METADATA_TYPE_CODE_EXECUTION_RESULT + == "code_execution_result" + ) + assert A2A_DATA_PART_METADATA_TYPE_EXECUTABLE_CODE == "executable_code" + + def test_convert_a2a_data_part_with_code_execution_result_metadata(self): + """Test conversion of A2A DataPart with code execution result metadata.""" + # Arrange + code_execution_result_data = { + "outcome": "OUTCOME_OK", + "output": "Hello, World!", + } + a2a_part = a2a_types.Part( + root=a2a_types.DataPart( + data=code_execution_result_data, + metadata={ + _get_adk_metadata_key( + A2A_DATA_PART_METADATA_TYPE_KEY + ): A2A_DATA_PART_METADATA_TYPE_CODE_EXECUTION_RESULT, + }, + ) + ) + + # Act + result = convert_a2a_part_to_genai_part(a2a_part) + + # Assert + assert result is not None + assert isinstance(result, genai_types.Part) + # Now it should convert back to a proper CodeExecutionResult + assert result.code_execution_result is not None + assert ( + result.code_execution_result.outcome == genai_types.Outcome.OUTCOME_OK + ) + assert result.code_execution_result.output == "Hello, World!" + + def test_convert_a2a_data_part_with_executable_code_metadata(self): + """Test conversion of A2A DataPart with executable code metadata.""" + # Arrange + executable_code_data = { + "language": "PYTHON", + "code": "print('Hello, World!')", + } + a2a_part = a2a_types.Part( + root=a2a_types.DataPart( + data=executable_code_data, + metadata={ + _get_adk_metadata_key( + A2A_DATA_PART_METADATA_TYPE_KEY + ): A2A_DATA_PART_METADATA_TYPE_EXECUTABLE_CODE, + }, + ) + ) + + # Act + result = convert_a2a_part_to_genai_part(a2a_part) + + # Assert + assert result is not None + assert isinstance(result, genai_types.Part) + # Now it should convert back to a proper ExecutableCode + assert result.executable_code is not None + assert result.executable_code.language == genai_types.Language.PYTHON + assert result.executable_code.code == "print('Hello, World!')"