fix(reviver): make from_json idempotent for object_hook use

Codex identified that ``json.loads(..., object_hook=reviver)`` revives
nested dicts bottom-up, so by the time ``ThreadImpl.from_json`` runs,
a payload's ``currentMessage`` is already a ``Message`` instance, not a
dict. The old code then called ``Message.from_json(current_msg_raw)``
on that Message, which raised ``AttributeError`` on ``.get`` and broke
deserialization of any serialized thread containing a currentMessage.

Fix:
- ``Message.from_json`` returns ``data`` unchanged if it's already a Message
- ``ThreadImpl.from_json`` / ``ChannelImpl.from_json`` do the same, plus
  pass the (possibly already-Message) ``currentMessage`` through the
  now-idempotent ``Message.from_json``
- Regression test exercises the exact object_hook bottom-up path with a
  nested currentMessage

Also moved ``TestStandaloneReviver``'s per-method local imports to the
module top level per gemini-code-assist review (PEP 8 E402).

https://claude.ai/code/session_01XE1bMoQ5BjCvgi1iLGKKhG

Author: claude

src/chat_sdk/channel.py

@@ -397,7 +397,7 @@ def to_json(self) -> dict[str, Any]:
     @classmethod
     def from_json(
         cls,
-        data: dict[str, Any],
+        data: dict[str, Any] | ChannelImpl,
         adapter: Adapter | None = None,
         chat: _ChatSingleton | None = None,
     ) -> ChannelImpl:
@@ -411,7 +411,13 @@ def from_json(
             Explicit adapter. Skips singleton lookup.
         chat:
             Explicit Chat instance for adapter/state resolution.
+
+        Idempotent: if ``data`` is already a :class:`ChannelImpl`, it is
+        returned unchanged. This makes it safe to call via
+        ``json.loads(..., object_hook=reviver)``.
         """
+        if isinstance(data, ChannelImpl):
+            return data
         channel = cls(
             _ChannelImplConfigLazy(
                 id=data["id"],

src/chat_sdk/thread.py

@@ -739,7 +739,7 @@ def to_json(self) -> dict[str, Any]:
     @classmethod
     def from_json(
         cls,
-        data: dict[str, Any],
+        data: dict[str, Any] | ThreadImpl,
         adapter: Adapter | None = None,
         chat: _ChatSingleton | None = None,
     ) -> ThreadImpl:
@@ -755,11 +755,17 @@ def from_json(
             Explicit Chat instance. If provided, adapter and state are resolved
             from this instance instead of the singleton. Useful in multi-chat
             or test scenarios.
+
+        Idempotent: if ``data`` is already a :class:`ThreadImpl`, it is
+        returned unchanged. This makes it safe to call via
+        ``json.loads(..., object_hook=reviver)``.
         """
+        if isinstance(data, ThreadImpl):
+            return data
         current_msg_raw = data.get("currentMessage") or data.get("current_message")
-        current_msg = None
-        if current_msg_raw:
-            current_msg = Message.from_json(current_msg_raw)
+        # ``object_hook`` revives nested dicts first, so ``currentMessage`` may
+        # already be a Message instance by the time this runs.
+        current_msg = Message.from_json(current_msg_raw) if current_msg_raw else None
 
         thread = cls(
             _ThreadImplConfig(

src/chat_sdk/types.py

@@ -436,14 +436,22 @@ def to_json(self) -> dict[str, Any]:
         return result
 
     @classmethod
-    def from_json(cls, data: dict[str, Any]) -> Message:
+    def from_json(cls, data: dict[str, Any] | Message) -> Message:
         """Reconstruct a Message from serialized JSON data.
 
         Converts ISO date strings back to ``datetime`` objects.
         Accepts both camelCase (canonical output of ``to_json()``) and
         snake_case keys for backward compatibility.  For explicit
         dual-format handling see :meth:`from_json_compat`.
+
+        Idempotent: if ``data`` is already a :class:`Message`, it is
+        returned unchanged. This makes it safe to call via
+        ``json.loads(..., object_hook=reviver)``, where nested values are
+        revived bottom-up and the outer dict may already contain a revived
+        instance.
         """
+        if isinstance(data, Message):
+            return data
         meta = data.get("metadata", {})
 
         date_sent_raw = meta.get("dateSent") or meta.get("date_sent")

tests/test_serialization.py

@@ -11,11 +11,14 @@
 
 import pytest
 
+from chat_sdk import reviver
+from chat_sdk.channel import ChannelImpl
+from chat_sdk.chat import Chat
 from chat_sdk.testing import (
     create_mock_adapter,
     create_test_message,
 )
-from chat_sdk.thread import ThreadImpl, _ThreadImplConfig
+from chat_sdk.thread import ThreadImpl, _ThreadImplConfig, clear_chat_singleton
 from chat_sdk.types import (
     Attachment,
     Author,
@@ -877,10 +880,6 @@ class TestStandaloneReviver:
     """
 
     def test_should_revive_chatthread_objects(self, mock_adapter, mock_state):
-        from chat_sdk import reviver
-        from chat_sdk.chat import Chat
-        from chat_sdk.thread import clear_chat_singleton
-
         chat = Chat(
             user_name="test-bot",
             adapters={"slack": mock_adapter},
@@ -907,10 +906,6 @@ def test_should_revive_chatthread_objects(self, mock_adapter, mock_state):
             clear_chat_singleton()
 
     def test_should_revive_chatmessage_objects(self, mock_adapter, mock_state):
-        from chat_sdk import reviver
-        from chat_sdk.chat import Chat
-        from chat_sdk.thread import clear_chat_singleton
-
         chat = Chat(
             user_name="test-bot",
             adapters={"slack": mock_adapter},
@@ -950,10 +945,6 @@ def test_should_revive_chatmessage_objects(self, mock_adapter, mock_state):
             clear_chat_singleton()
 
     def test_should_revive_both_thread_and_message_in_same_payload(self, mock_adapter, mock_state):
-        from chat_sdk import reviver
-        from chat_sdk.chat import Chat
-        from chat_sdk.thread import clear_chat_singleton
-
         chat = Chat(
             user_name="test-bot",
             adapters={"slack": mock_adapter},
@@ -1000,8 +991,6 @@ def test_should_revive_both_thread_and_message_in_same_payload(self, mock_adapte
             clear_chat_singleton()
 
     def test_should_leave_nonchat_objects_unchanged(self, mock_adapter, mock_state):
-        from chat_sdk import reviver
-
         payload = json.dumps(
             {
                 "name": "test",
@@ -1015,10 +1004,6 @@ def test_should_leave_nonchat_objects_unchanged(self, mock_adapter, mock_state):
         assert parsed["nested"]["_type"] == "other:Type"
 
     def test_should_be_usable_directly_as_json_parse_second_argument(self, mock_adapter, mock_state):
-        from chat_sdk import reviver
-        from chat_sdk.chat import Chat
-        from chat_sdk.thread import clear_chat_singleton
-
         chat = Chat(
             user_name="test-bot",
             adapters={"slack": mock_adapter},
@@ -1055,8 +1040,6 @@ def test_should_be_usable_directly_as_json_parse_second_argument(self, mock_adap
             clear_chat_singleton()
 
     def test_should_allow_reserialization_of_a_revived_thread_without_singleton(self):
-        from chat_sdk.thread import clear_chat_singleton
-
         clear_chat_singleton()
         data = {
             "_type": "chat:Thread",
@@ -1072,9 +1055,6 @@ def test_should_allow_reserialization_of_a_revived_thread_without_singleton(self
         assert reserialized["id"] == "slack:C123:1234.5678"
 
     def test_should_allow_reserialization_of_a_revived_channel_without_singleton(self):
-        from chat_sdk.channel import ChannelImpl
-        from chat_sdk.thread import clear_chat_singleton
-
         clear_chat_singleton()
         data = {
             "_type": "chat:Channel",
@@ -1088,6 +1068,55 @@ def test_should_allow_reserialization_of_a_revived_channel_without_singleton(sel
         assert reserialized["adapterName"] == "slack"
         assert reserialized["id"] == "C123"
 
+    def test_should_revive_thread_with_nested_current_message_via_object_hook(self, mock_adapter, mock_state):
+        """``object_hook`` revives children first, so ``currentMessage`` reaches
+        ``ThreadImpl.from_json`` as a :class:`Message` instance, not a dict.
+        ``from_json`` must accept that without raising ``AttributeError``."""
+        chat = Chat(
+            user_name="test-bot",
+            adapters={"slack": mock_adapter},
+            state=mock_state,
+            logger="silent",
+        )
+        chat.register_singleton()
+        try:
+            payload = json.dumps(
+                {
+                    "_type": "chat:Thread",
+                    "id": "slack:C123:1234.5678",
+                    "channelId": "C123",
+                    "isDM": False,
+                    "adapterName": "slack",
+                    "currentMessage": {
+                        "_type": "chat:Message",
+                        "id": "msg-current",
+                        "threadId": "slack:C123:1234.5678",
+                        "text": "hi",
+                        "formatted": {"type": "root", "children": []},
+                        "raw": {},
+                        "author": {
+                            "userId": "U123",
+                            "userName": "testuser",
+                            "fullName": "Test User",
+                            "isBot": False,
+                            "isMe": False,
+                        },
+                        "metadata": {
+                            "dateSent": "2024-01-15T10:30:00.000Z",
+                            "edited": False,
+                        },
+                        "attachments": [],
+                    },
+                }
+            )
+            thread = json.loads(payload, object_hook=reviver)
+            assert isinstance(thread, ThreadImpl)
+            assert thread._current_message is not None
+            assert isinstance(thread._current_message, Message)
+            assert thread._current_message.id == "msg-current"
+        finally:
+            clear_chat_singleton()
+
 
 # ============================================================================
 # @workflow/serde integration — ThreadImpl