fix: reviver() uses explicit chat= instead of global singleton

reviver() was calling register_singleton() and using bare
from_json() calls, reintroducing ambient global state even though
the 3-level resolver exists. Now uses chat= parameter for explicit
resolution without side effects.

Also adds 18 tests for the resolver:
- Global singleton register/resolve/clear
- ContextVar activation scoping and nesting
- Explicit chat= beats context and global
- Concurrent tasks don't bleed across ContextVars
- reviver() doesn't register singleton, binds to specific chat

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: patrick-chinchill

src/chat_sdk/chat.py

@@ -759,17 +759,19 @@ def get_adapter_by_name(self, name: str) -> Adapter | None:
     def reviver(self) -> Callable[[str, Any], Any]:
         """Return a JSON reviver that deserializes Thread/Channel/Message objects.
 
-        Ensures this Chat instance is the registered singleton.
+        Uses explicit ``chat=self`` for deserialization instead of mutating
+        process-global state. Each Chat instance produces a reviver bound
+        to itself.
         """
-        self.register_singleton()
+        chat = self
 
         def _reviver(key: str, value: Any) -> Any:
             if isinstance(value, dict) and "_type" in value:
                 t = value["_type"]
                 if t == "chat:Thread":
-                    return ThreadImpl.from_json(value)
+                    return ThreadImpl.from_json(value, chat=chat)
                 if t == "chat:Channel":
-                    return ChannelImpl.from_json(value)
+                    return ChannelImpl.from_json(value, chat=chat)
                 if t == "chat:Message":
                     return _message_from_json(value)
             return value

tests/test_chat_resolver.py

@@ -0,0 +1,252 @@
+"""Tests for the 3-level Chat resolver (ContextVar → global → error).
+
+Verifies:
+- chat.activate() scopes resolution to the current context
+- Explicit chat= parameter beats context and global
+- Multiple concurrent chats don't bleed across tasks
+- reviver() uses explicit chat= instead of global singleton
+- clear_chat_singleton() resets both levels
+"""
+
+from __future__ import annotations
+
+import asyncio
+
+import pytest
+
+from chat_sdk import Chat, MemoryStateAdapter
+from chat_sdk.testing import create_mock_adapter
+from chat_sdk.thread import (
+    ThreadImpl,
+    clear_chat_singleton,
+    get_chat_singleton,
+    has_chat_singleton,
+)
+
+
+def _make_chat(name: str = "slack") -> Chat:
+    adapter = create_mock_adapter(name)
+    state = MemoryStateAdapter()
+    return Chat(adapters={name: adapter}, state=state, user_name=f"{name}-bot")
+
+
+def _thread_json(adapter_name: str = "slack") -> dict:
+    return {
+        "_type": "chat:Thread",
+        "id": "t1",
+        "channelId": f"{adapter_name}:C1",
+        "channelVisibility": "public",
+        "isDM": False,
+        "adapterName": adapter_name,
+    }
+
+
+class TestGlobalSingleton:
+    """Existing register_singleton pattern still works."""
+
+    def setup_method(self):
+        clear_chat_singleton()
+
+    def teardown_method(self):
+        clear_chat_singleton()
+
+    def test_register_and_resolve(self):
+        chat = _make_chat()
+        chat.register_singleton()
+        assert get_chat_singleton() is chat
+
+    def test_has_singleton_false_before_register(self):
+        assert not has_chat_singleton()
+
+    def test_has_singleton_true_after_register(self):
+        chat = _make_chat()
+        chat.register_singleton()
+        assert has_chat_singleton()
+
+    def test_clear_resets(self):
+        chat = _make_chat()
+        chat.register_singleton()
+        clear_chat_singleton()
+        assert not has_chat_singleton()
+
+    def test_error_when_no_singleton(self):
+        with pytest.raises(RuntimeError, match="No Chat instance available"):
+            get_chat_singleton()
+
+
+class TestContextVarActivation:
+    """chat.activate() scopes resolution to the current context."""
+
+    def setup_method(self):
+        clear_chat_singleton()
+
+    def teardown_method(self):
+        clear_chat_singleton()
+
+    def test_activate_scopes_to_context(self):
+        chat = _make_chat()
+        with chat.activate():
+            assert get_chat_singleton() is chat
+        # Outside context, no singleton
+        assert not has_chat_singleton()
+
+    def test_activate_overrides_global(self):
+        global_chat = _make_chat("global")
+        local_chat = _make_chat("local")
+        global_chat.register_singleton()
+
+        assert get_chat_singleton() is global_chat
+
+        with local_chat.activate():
+            assert get_chat_singleton() is local_chat
+
+        # After exit, global is restored
+        assert get_chat_singleton() is global_chat
+
+    def test_nested_activate(self):
+        chat_a = _make_chat("a")
+        chat_b = _make_chat("b")
+
+        with chat_a.activate():
+            assert get_chat_singleton() is chat_a
+            with chat_b.activate():
+                assert get_chat_singleton() is chat_b
+            # Back to chat_a after inner exit
+            assert get_chat_singleton() is chat_a
+
+    def test_from_json_resolves_via_activate(self):
+        chat = _make_chat("slack")
+        data = _thread_json("slack")
+
+        with chat.activate():
+            thread = ThreadImpl.from_json(data)
+            assert thread.adapter is not None
+            assert thread.adapter.name == "slack"
+
+
+class TestExplicitChatParameter:
+    """Explicit chat= parameter on from_json beats all fallbacks."""
+
+    def setup_method(self):
+        clear_chat_singleton()
+
+    def teardown_method(self):
+        clear_chat_singleton()
+
+    def test_explicit_chat_beats_global(self):
+        global_chat = _make_chat("global")
+        explicit_chat = _make_chat("explicit")
+        global_chat.register_singleton()
+
+        data = _thread_json("explicit")
+        thread = ThreadImpl.from_json(data, chat=explicit_chat)
+        assert thread.adapter.name == "explicit"
+
+    def test_explicit_chat_beats_contextvar(self):
+        context_chat = _make_chat("context")
+        explicit_chat = _make_chat("explicit")
+
+        data = _thread_json("explicit")
+        with context_chat.activate():
+            thread = ThreadImpl.from_json(data, chat=explicit_chat)
+            assert thread.adapter.name == "explicit"
+
+    def test_explicit_chat_works_without_any_singleton(self):
+        chat = _make_chat("solo")
+        data = _thread_json("solo")
+        thread = ThreadImpl.from_json(data, chat=chat)
+        assert thread.adapter.name == "solo"
+
+
+class TestConcurrentIsolation:
+    """Multiple concurrent chats don't bleed across tasks."""
+
+    def setup_method(self):
+        clear_chat_singleton()
+
+    def teardown_method(self):
+        clear_chat_singleton()
+
+    async def test_concurrent_tasks_isolated(self):
+        chat_a = _make_chat("adapter_a")
+        chat_b = _make_chat("adapter_b")
+        results: dict[str, str] = {}
+
+        async def task(chat: Chat, name: str) -> None:
+            with chat.activate():
+                # Yield to let the other task run
+                await asyncio.sleep(0.01)
+                resolved = get_chat_singleton()
+                results[name] = resolved._user_name
+
+        await asyncio.gather(
+            task(chat_a, "a"),
+            task(chat_b, "b"),
+        )
+
+        assert results["a"] == "adapter_a-bot"
+        assert results["b"] == "adapter_b-bot"
+
+    async def test_concurrent_from_json_isolated(self):
+        chat_a = _make_chat("aa")
+        chat_b = _make_chat("bb")
+        results: dict[str, str] = {}
+
+        async def task(chat: Chat, adapter_name: str) -> None:
+            data = _thread_json(adapter_name)
+            with chat.activate():
+                await asyncio.sleep(0.01)
+                thread = ThreadImpl.from_json(data)
+                results[adapter_name] = thread.adapter.name
+
+        await asyncio.gather(
+            task(chat_a, "aa"),
+            task(chat_b, "bb"),
+        )
+
+        assert results["aa"] == "aa"
+        assert results["bb"] == "bb"
+
+
+class TestReviver:
+    """reviver() uses explicit chat= instead of global singleton."""
+
+    def setup_method(self):
+        clear_chat_singleton()
+
+    def teardown_method(self):
+        clear_chat_singleton()
+
+    def test_reviver_does_not_register_singleton(self):
+        chat = _make_chat()
+        _reviver = chat.reviver()
+        # reviver() should NOT register a global singleton
+        assert not has_chat_singleton()
+
+    def test_reviver_deserializes_thread(self):
+        chat = _make_chat("slack")
+        reviver = chat.reviver()
+        data = _thread_json("slack")
+        thread = reviver("key", data)
+        assert isinstance(thread, ThreadImpl)
+        assert thread.adapter.name == "slack"
+
+    def test_reviver_bound_to_specific_chat(self):
+        chat_a = _make_chat("a")
+        chat_b = _make_chat("b")
+
+        reviver_a = chat_a.reviver()
+        reviver_b = chat_b.reviver()
+
+        thread_a = reviver_a("k", _thread_json("a"))
+        thread_b = reviver_b("k", _thread_json("b"))
+
+        assert thread_a.adapter.name == "a"
+        assert thread_b.adapter.name == "b"
+
+    def test_reviver_passes_through_non_typed_values(self):
+        chat = _make_chat()
+        reviver = chat.reviver()
+        assert reviver("key", "plain string") == "plain string"
+        assert reviver("key", 42) == 42
+        assert reviver("key", {"no_type": True}) == {"no_type": True}