From 851739d59971a7bd2ff7eeea1d98d251604e568d Mon Sep 17 00:00:00 2001 From: Hardik Kaurani Date: Sun, 15 Nov 2026 16:36:50 +0530 Subject: [PATCH 1/6] test(serialization): add failing tests for tuple attributes in SerializationMixin --- .../core/tests/core/test_serializable_mixin.py | 15 +++++++++++++++ 1 file changed, 15 insertions(+) diff --git a/python/packages/core/tests/core/test_serializable_mixin.py b/python/packages/core/tests/core/test_serializable_mixin.py index 2beb32f8f28..dfcd1b4c577 100644 --- a/python/packages/core/tests/core/test_serializable_mixin.py +++ b/python/packages/core/tests/core/test_serializable_mixin.py @@ -800,3 +800,18 @@ 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"] From 63d9787dcf8c4cb81feb8448096b7a5e3fee5f37 Mon Sep 17 00:00:00 2001 From: Hardik Kaurani Date: Sun, 15 Nov 2026 16:37:27 +0530 Subject: [PATCH 2/6] fix(serialization): serialize tuple values to JSON-compatible lists in _serialize_value --- python/packages/core/agent_framework/_serialization.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/python/packages/core/agent_framework/_serialization.py b/python/packages/core/agent_framework/_serialization.py index 257ac095dc8..6acd07a2ee7 100644 --- a/python/packages/core/agent_framework/_serialization.py +++ b/python/packages/core/agent_framework/_serialization.py @@ -178,15 +178,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, From 220e46d80bfc72d78d74ec615995728fbfdac44f Mon Sep 17 00:00:00 2001 From: Hardik Kaurani Date: Sun, 15 Nov 2026 16:37:51 +0530 Subject: [PATCH 3/6] test(serialization): verify nested tuples within lists and dictionaries --- .../core/tests/core/test_serializable_mixin.py | 18 ++++++++++++++++++ 1 file changed, 18 insertions(+) diff --git a/python/packages/core/tests/core/test_serializable_mixin.py b/python/packages/core/tests/core/test_serializable_mixin.py index dfcd1b4c577..ac4f7107134 100644 --- a/python/packages/core/tests/core/test_serializable_mixin.py +++ b/python/packages/core/tests/core/test_serializable_mixin.py @@ -815,3 +815,21 @@ def __init__(self, coordinates: tuple[float, float], labels: tuple[str, ...]): 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"]} From f28c01eb6ae12b102f3360564169beb96fbcce83 Mon Sep 17 00:00:00 2001 From: Hardik Kaurani Date: Sun, 15 Nov 2026 16:38:10 +0530 Subject: [PATCH 4/6] test(serialization): verify empty and single-element tuples --- .../core/tests/core/test_serializable_mixin.py | 15 +++++++++++++++ 1 file changed, 15 insertions(+) diff --git a/python/packages/core/tests/core/test_serializable_mixin.py b/python/packages/core/tests/core/test_serializable_mixin.py index ac4f7107134..94d31c14954 100644 --- a/python/packages/core/tests/core/test_serializable_mixin.py +++ b/python/packages/core/tests/core/test_serializable_mixin.py @@ -833,3 +833,18 @@ def __init__(self, items: list[tuple[int, int]], mapping: dict[str, tuple[str, s 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] From 87c93d77177abda3eb674694608231d48ab8c6bf Mon Sep 17 00:00:00 2001 From: Hardik Kaurani Date: Sun, 15 Nov 2026 16:38:50 +0530 Subject: [PATCH 5/6] docs(serialization): document tuple sequence support in _serialize_value --- python/packages/core/agent_framework/_serialization.py | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/python/packages/core/agent_framework/_serialization.py b/python/packages/core/agent_framework/_serialization.py index 6acd07a2ee7..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: From e5dda4bfe60ea129f21faf0284a2fc101072f049 Mon Sep 17 00:00:00 2001 From: Hardik Kaurani Date: Sun, 15 Nov 2026 16:39:10 +0530 Subject: [PATCH 6/6] test(serialization): verify mixed list and tuple sequence serialization --- .../core/tests/core/test_serializable_mixin.py | 18 ++++++++++++++++++ 1 file changed, 18 insertions(+) diff --git a/python/packages/core/tests/core/test_serializable_mixin.py b/python/packages/core/tests/core/test_serializable_mixin.py index 94d31c14954..7241a3e0cc1 100644 --- a/python/packages/core/tests/core/test_serializable_mixin.py +++ b/python/packages/core/tests/core/test_serializable_mixin.py @@ -848,3 +848,21 @@ def __init__(self, empty: tuple[()], single: tuple[int]): 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"]]