diff --git a/python/packages/core/agent_framework/_serialization.py b/python/packages/core/agent_framework/_serialization.py index 257ac095dc8..8f148588a52 100644 --- a/python/packages/core/agent_framework/_serialization.py +++ b/python/packages/core/agent_framework/_serialization.py @@ -164,7 +164,11 @@ def _serialize_value( active_container_ids: set[int] | None = None, stringify_dict_keys: bool = False, ) -> Any: - """Recursively serialize a value while preserving skip semantics.""" + """Recursively serialize a value while preserving skip semantics. + + Supports JSON-compatible scalars, serializable objects, mappings, and sequences + including lists and tuples. + """ if active_container_ids is None: active_container_ids = set() if type(value) in _JSON_SCALAR_TYPES: @@ -178,15 +182,15 @@ def _serialize_value( attribute_name=attribute_name, active_container_ids=active_container_ids, ) - if isinstance(value, list): - value_as_list = cast(list[Any], value) - container_id = id(value_as_list) + if isinstance(value, (list, tuple)): + value_as_sequence = cast(list[Any] | tuple[Any, ...], value) + container_id = id(value_as_sequence) if container_id in active_container_ids: raise ValueError("Circular reference detected") active_container_ids.add(container_id) try: serialized_list: list[Any] = [] - for item in value_as_list: + for item in value_as_sequence: serialized = _serialize_value( item, exclude=exclude, diff --git a/python/packages/core/tests/core/test_serializable_mixin.py b/python/packages/core/tests/core/test_serializable_mixin.py index 2beb32f8f28..7241a3e0cc1 100644 --- a/python/packages/core/tests/core/test_serializable_mixin.py +++ b/python/packages/core/tests/core/test_serializable_mixin.py @@ -800,3 +800,69 @@ def __init__(self, name: str, config: dict | None = None): assert input_data == original_input assert input_data["config"] == {"base": True} assert "injected" not in input_data["config"] + + def test_tuple_attribute_serialization(self): + """Test that tuple attributes are serialized to JSON-compatible lists.""" + + class Location(SerializationMixin): + def __init__(self, coordinates: tuple[float, float], labels: tuple[str, ...]): + self.coordinates = coordinates + self.labels = labels + + loc = Location(coordinates=(12.34, 56.78), labels=("alpha", "beta")) + data = loc.to_dict() + + assert data["type"] == "location" + assert data["coordinates"] == [12.34, 56.78] + assert data["labels"] == ["alpha", "beta"] + + def test_nested_tuple_serialization(self): + """Test that tuples nested inside lists and dictionaries are properly serialized.""" + + class Container(SerializationMixin): + def __init__(self, items: list[tuple[int, int]], mapping: dict[str, tuple[str, str]]): + self.items = items + self.mapping = mapping + + obj = Container( + items=[(1, 2), (3, 4)], + mapping={"coords": ("x", "y")}, + ) + data = obj.to_dict() + + assert data["type"] == "container" + assert data["items"] == [[1, 2], [3, 4]] + assert data["mapping"] == {"coords": ["x", "y"]} + + def test_empty_and_single_element_tuple_serialization(self): + """Test that empty and single-element tuples are serialized properly.""" + + class EdgeCases(SerializationMixin): + def __init__(self, empty: tuple[()], single: tuple[int]): + self.empty = empty + self.single = single + + obj = EdgeCases(empty=(), single=(42,)) + data = obj.to_dict() + + assert data["type"] == "edge_cases" + assert data["empty"] == [] + assert data["single"] == [42] + + def test_mixed_tuple_and_list_serialization(self): + """Test that mixed list-of-tuples and tuple-of-lists serialize to list-of-lists.""" + + class Mixed(SerializationMixin): + def __init__(self, tuple_of_lists: tuple[list[int], ...], list_of_tuples: list[tuple[str, ...]]): + self.tuple_of_lists = tuple_of_lists + self.list_of_tuples = list_of_tuples + + obj = Mixed( + tuple_of_lists=([1, 2], [3, 4]), + list_of_tuples=[("a", "b"), ("c", "d")], + ) + data = obj.to_dict() + + assert data["type"] == "mixed" + assert data["tuple_of_lists"] == [[1, 2], [3, 4]] + assert data["list_of_tuples"] == [["a", "b"], ["c", "d"]]