Skip to content
14 changes: 9 additions & 5 deletions python/packages/core/agent_framework/_serialization.py
Original file line number Diff line number Diff line change
Expand Up @@ -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:
Expand All @@ -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,
Expand Down
66 changes: 66 additions & 0 deletions python/packages/core/tests/core/test_serializable_mixin.py
Original file line number Diff line number Diff line change
Expand Up @@ -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"]]
Loading