From 45cd21126e869321359148df53e7c4e351c567b9 Mon Sep 17 00:00:00 2001 From: Hardik Kaurani Date: Sun, 15 Nov 2026 16:44:26 +0530 Subject: [PATCH 1/6] test(serialization): add failing tests for slot-backed SerializationMixin fields --- .../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 2beb32f8f28..4498d3476f2 100644 --- a/python/packages/core/tests/core/test_serializable_mixin.py +++ b/python/packages/core/tests/core/test_serializable_mixin.py @@ -800,3 +800,21 @@ 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_to_dict_includes_slot_fields(self): + """Test that to_dict includes public fields defined in __slots__.""" + + class SlotBacked(SerializationMixin): + __slots__ = ("value",) + + def __init__(self, value: str): + self.value = value + + obj = SlotBacked("hello") + data = obj.to_dict() + + assert data["type"] == "slot_backed" + assert data["value"] == "hello" + + restored = SlotBacked.from_dict(data) + assert restored.value == "hello" From 717b1dc7a3281e0db9ff155db3491fd192f01e85 Mon Sep 17 00:00:00 2001 From: Hardik Kaurani Date: Sun, 15 Nov 2026 16:44:52 +0530 Subject: [PATCH 2/6] fix(serialization): include slot-backed instance fields in to_dict using _iter_instance_fields --- python/packages/core/agent_framework/_serialization.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/python/packages/core/agent_framework/_serialization.py b/python/packages/core/agent_framework/_serialization.py index 257ac095dc8..2bd5d6336ad 100644 --- a/python/packages/core/agent_framework/_serialization.py +++ b/python/packages/core/agent_framework/_serialization.py @@ -464,7 +464,7 @@ def to_dict(self, *, exclude: set[str] | None = None, exclude_none: bool = True) # Get all instance attributes result: dict[str, Any] = {} if "type" in combined_exclude else {"type": self._get_type_identifier()} - for key, value in self.__dict__.items(): + for key, value in _iter_instance_fields(self).items(): if key not in combined_exclude and not key.startswith("_"): if exclude_none and value is None: continue From 2ad33146f3e416b5b2b55f25b0c1b55bb0ca129e Mon Sep 17 00:00:00 2001 From: Hardik Kaurani Date: Sun, 15 Nov 2026 16:45:15 +0530 Subject: [PATCH 3/6] test(serialization): verify slot-backed fields respect exclusion rules in to_dict --- .../tests/core/test_serializable_mixin.py | 24 +++++++++++++++++++ 1 file changed, 24 insertions(+) diff --git a/python/packages/core/tests/core/test_serializable_mixin.py b/python/packages/core/tests/core/test_serializable_mixin.py index 4498d3476f2..dbb6502ec38 100644 --- a/python/packages/core/tests/core/test_serializable_mixin.py +++ b/python/packages/core/tests/core/test_serializable_mixin.py @@ -818,3 +818,27 @@ def __init__(self, value: str): restored = SlotBacked.from_dict(data) assert restored.value == "hello" + + def test_slot_fields_respect_exclusion_and_private_rules(self): + """Test that slot-backed fields respect DEFAULT_EXCLUDE, explicit exclude, and private prefixes.""" + + class SlotExclusions(SerializationMixin): + __slots__ = ("public_field", "secret_field", "_private_field") + DEFAULT_EXCLUDE = {"secret_field"} + + def __init__(self, public_field: str, secret_field: str, private_field: str): + self.public_field = public_field + self.secret_field = secret_field + self._private_field = private_field + + obj = SlotExclusions(public_field="pub", secret_field="sec", private_field="priv") + data = obj.to_dict() + + assert data["type"] == "slot_exclusions" + assert data["public_field"] == "pub" + assert "secret_field" not in data + assert "_private_field" not in data + + # Test explicit exclude + data_excluded = obj.to_dict(exclude={"public_field"}) + assert "public_field" not in data_excluded From 112119505820404d3b27420a13f7df9fd40b0403 Mon Sep 17 00:00:00 2001 From: Hardik Kaurani Date: Sun, 15 Nov 2026 16:45:34 +0530 Subject: [PATCH 4/6] test(serialization): verify slot-backed fields round trip through to_json and from_json --- .../tests/core/test_serializable_mixin.py | 22 +++++++++++++++++++ 1 file changed, 22 insertions(+) diff --git a/python/packages/core/tests/core/test_serializable_mixin.py b/python/packages/core/tests/core/test_serializable_mixin.py index dbb6502ec38..25146f5e524 100644 --- a/python/packages/core/tests/core/test_serializable_mixin.py +++ b/python/packages/core/tests/core/test_serializable_mixin.py @@ -842,3 +842,25 @@ def __init__(self, public_field: str, secret_field: str, private_field: str): # Test explicit exclude data_excluded = obj.to_dict(exclude={"public_field"}) assert "public_field" not in data_excluded + + def test_slot_fields_to_json_and_from_json_round_trip(self): + """Test that slot-backed objects round trip correctly through to_json and from_json.""" + + class Point3D(SerializationMixin): + __slots__ = ("x", "y", "z") + + def __init__(self, x: float, y: float, z: float): + self.x = x + self.y = y + self.z = z + + pt = Point3D(1.5, 2.5, 3.5) + raw_json = pt.to_json() + parsed = json.loads(raw_json) + + assert parsed == {"type": "point3_d", "x": 1.5, "y": 2.5, "z": 3.5} + + restored = Point3D.from_json(raw_json) + assert restored.x == 1.5 + assert restored.y == 2.5 + assert restored.z == 3.5 From bf40f51ffcbfe7a4220ece4a5484b55877c12bd4 Mon Sep 17 00:00:00 2001 From: Hardik Kaurani Date: Sun, 15 Nov 2026 16:45:51 +0530 Subject: [PATCH 5/6] docs(serialization): document slot-backed field support in to_dict docstring --- python/packages/core/agent_framework/_serialization.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/python/packages/core/agent_framework/_serialization.py b/python/packages/core/agent_framework/_serialization.py index 2bd5d6336ad..5a552afef30 100644 --- a/python/packages/core/agent_framework/_serialization.py +++ b/python/packages/core/agent_framework/_serialization.py @@ -441,7 +441,8 @@ def to_dict(self, *, exclude: set[str] | None = None, exclude_none: bool = True) This method performs deep serialization, automatically converting nested ``SerializationProtocol`` objects, lists, and dictionaries containing - serializable objects. Non-serializable objects are skipped with debug logging. + serializable objects. Attributes stored in either ``__dict__`` or ``__slots__`` + are included. Non-serializable objects are skipped with debug logging. Fields marked in ``DEFAULT_EXCLUDE`` and ``INJECTABLE`` are automatically excluded from the output, as are any private attributes (starting with '_'). From c7e3e982009ad3d260a991e893c77f01a591195a Mon Sep 17 00:00:00 2001 From: Hardik Kaurani Date: Sun, 15 Nov 2026 16:46:11 +0530 Subject: [PATCH 6/6] test(serialization): verify inheritance hierarchy with mixed dict and slot attributes --- .../tests/core/test_serializable_mixin.py | 25 +++++++++++++++++++ 1 file changed, 25 insertions(+) diff --git a/python/packages/core/tests/core/test_serializable_mixin.py b/python/packages/core/tests/core/test_serializable_mixin.py index 25146f5e524..299f02e174b 100644 --- a/python/packages/core/tests/core/test_serializable_mixin.py +++ b/python/packages/core/tests/core/test_serializable_mixin.py @@ -864,3 +864,28 @@ def __init__(self, x: float, y: float, z: float): assert restored.x == 1.5 assert restored.y == 2.5 assert restored.z == 3.5 + + def test_slot_inheritance_hierarchy_serialization(self): + """Test serialization across class hierarchies with mixed slots and regular attributes.""" + + class BaseSlot(SerializationMixin): + __slots__ = ("base_id",) + + def __init__(self, base_id: str): + self.base_id = base_id + + class DerivedWithDict(BaseSlot): + def __init__(self, base_id: str, derived_name: str): + super().__init__(base_id) + self.derived_name = derived_name + + obj = DerivedWithDict(base_id="b1", derived_name="d1") + data = obj.to_dict() + + assert data["type"] == "derived_with_dict" + assert data["base_id"] == "b1" + assert data["derived_name"] == "d1" + + restored = DerivedWithDict.from_dict(data) + assert restored.base_id == "b1" + assert restored.derived_name == "d1"