address coderabbit review findings

- [critical] thread._fallback_stream: wrap the placeholder-clear
  edit_message(" ") in try/except so Telegram (which raises
  ValidationError on whitespace-only text) logs and falls back to
  upstream's stranded-placeholder behavior instead of propagating
  a crash up through thread.post().
- [major] pyrefly python-version 3.11 -> 3.10 to match
  requires-python. Otherwise type-check target drifts ahead of the
  package's claimed support floor.
- [major] test_chat_faithful.py: the fallback-streaming test now
  verifies the final posted markdown is "Hi", not just that some
  post happened on the right thread.
- [minor] test_thread_faithful.py: three "no empty content" tests
  were vacuous — they iterated PostableMarkdown calls inside an
  isinstance guard but never asserted that any calls happened, so
  the tests passed even if the SDK emitted nothing. Now assert at
  least one matching call before checking content.
- [nit] channel.py / thread.py from_json: replace `or` truthiness
  chain on camel-to-snake fallback keys with explicit None checks.
  `""` is a valid-but-falsy value that shouldn't silently fall
  through to the alias.

https://claude.ai/code/session_01XE1bMoQ5BjCvgi1iLGKKhG

Author: claude

pyproject.toml

@@ -93,7 +93,7 @@ project-excludes = ["**/__pycache__", "**/.pytest_cache"]
 disable-project-excludes-heuristics = true
 use-ignore-files = false
 
-python-version = "3.11"
+python-version = "3.10"
 python-platform = "linux"
 
 # Optional adapter deps that aren't in the default install. Treating them as

src/chat_sdk/channel.py

@@ -389,7 +389,7 @@ def to_json(self) -> dict[str, Any]:
         return {
             "_type": "chat:Channel",
             "id": self._id,
-            "adapterName": self._adapter_name or self.adapter.name,
+            "adapterName": self._adapter_name if self._adapter_name else self.adapter.name,
             "channelVisibility": self._channel_visibility,
             "isDM": self._is_dm,
         }
@@ -418,11 +418,18 @@ def from_json(
         """
         if isinstance(data, ChannelImpl):
             return data
+        # Explicit None-checks (not `or`) to avoid the truthiness trap:
+        # `""` is a valid-but-falsy value that shouldn't silently fall
+        # through to the snake_case alias. See UPSTREAM_SYNC.md hazard #1.
+        raw_adapter_name = data["adapterName"] if "adapterName" in data else data.get("adapter_name")
+        raw_channel_visibility = (
+            data["channelVisibility"] if "channelVisibility" in data else data.get("channel_visibility")
+        )
         channel = cls(
             _ChannelImplConfigLazy(
                 id=data["id"],
-                adapter_name=data.get("adapterName") or data.get("adapter_name", ""),
-                channel_visibility=data.get("channelVisibility") or data.get("channel_visibility", "unknown"),
+                adapter_name=raw_adapter_name if raw_adapter_name is not None else "",
+                channel_visibility=raw_channel_visibility if raw_channel_visibility is not None else "unknown",
                 is_dm=data.get("isDM") if "isDM" in data else data.get("is_dm", False),
             )
         )

src/chat_sdk/thread.py

@@ -680,12 +680,23 @@ async def _edit_loop() -> None:
             # "..." on the message forever. We replace it with " " so the
             # placeholder is cleared consistently with the no-placeholder branch
             # (which also posts " " in this case). See docs/UPSTREAM_SYNC.md.
-            await self.adapter.edit_message(
-                thread_id_for_edits,
-                msg.id,
-                PostableMarkdown(markdown=" "),
-            )
-            last_edit_content = " "
+            #
+            # Some adapters (e.g. Telegram) reject whitespace-only content with
+            # a ValidationError. If the edit fails, we log and fall back to
+            # upstream's "leave placeholder visible" behavior for that adapter.
+            try:
+                await self.adapter.edit_message(
+                    thread_id_for_edits,
+                    msg.id,
+                    PostableMarkdown(markdown=" "),
+                )
+                last_edit_content = " "
+            except Exception as exc:
+                if self._logger:
+                    self._logger.warn(
+                        "fallbackStream placeholder-clear edit failed; placeholder will remain visible",
+                        exc,
+                    )
 
         sent = self._create_sent_message(
             msg.id,
@@ -733,7 +744,7 @@ def to_json(self) -> dict[str, Any]:
             "channelVisibility": self._channel_visibility,
             "currentMessage": self._current_message.to_json() if self._current_message else None,
             "isDM": self._is_dm,
-            "adapterName": self._adapter_name or self.adapter.name,
+            "adapterName": self._adapter_name if self._adapter_name else self.adapter.name,
         }
 
     @classmethod
@@ -762,17 +773,26 @@ def from_json(
         """
         if isinstance(data, ThreadImpl):
             return data
-        current_msg_raw = data.get("currentMessage") or data.get("current_message")
+        # Explicit None-checks (not `or`) to avoid the truthiness trap:
+        # `""` is a valid-but-falsy value that shouldn't silently fall
+        # through to the snake_case alias. See UPSTREAM_SYNC.md hazard #1.
+        raw_current = data["currentMessage"] if "currentMessage" in data else data.get("current_message")
         # ``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
+        current_msg = Message.from_json(raw_current) if raw_current is not None else None
+
+        raw_adapter_name = data["adapterName"] if "adapterName" in data else data.get("adapter_name")
+        raw_channel_id = data["channelId"] if "channelId" in data else data.get("channel_id")
+        raw_channel_visibility = (
+            data["channelVisibility"] if "channelVisibility" in data else data.get("channel_visibility")
+        )
 
         thread = cls(
             _ThreadImplConfig(
                 id=data["id"],
-                adapter_name=data.get("adapterName") or data.get("adapter_name", ""),
-                channel_id=data.get("channelId") or data.get("channel_id", ""),
-                channel_visibility=data.get("channelVisibility") or data.get("channel_visibility", "unknown"),
+                adapter_name=raw_adapter_name if raw_adapter_name is not None else "",
+                channel_id=raw_channel_id if raw_channel_id is not None else "",
+                channel_visibility=raw_channel_visibility if raw_channel_visibility is not None else "unknown",
                 current_message=current_msg,
                 is_dm=data.get("isDM") if "isDM" in data else data.get("is_dm", False),
             )

tests/test_chat_faithful.py

@@ -348,8 +348,10 @@ async def _stream():
         # guard defers the first commit until stream end, so the final content
         # arrives via post rather than an intermediate edit.
         assert len(adapter._post_calls) >= 1
-        last_post = adapter._post_calls[-1]
-        assert last_post[0] == "slack:C123:1234.5678"
+        last_thread_id, last_content = adapter._post_calls[-1]
+        assert last_thread_id == "slack:C123:1234.5678"
+        last_markdown = last_content.markdown if hasattr(last_content, "markdown") else last_content
+        assert last_markdown == "Hi"
 
 
 # ============================================================================

tests/test_thread_faithful.py

@@ -439,9 +439,9 @@ async def test_should_not_post_empty_content_when_table_is_buffered_with_null_pl
         text_stream = _create_text_stream(["| A | B |\n", "|---|---|\n", "| 1 | 2 |\n"])
         await thread.post(text_stream)
 
-        for _, content in adapter._post_calls:
-            if isinstance(content, PostableMarkdown):
-                assert len(content.markdown.strip()) > 0
+        markdown_posts = [content for _, content in adapter._post_calls if isinstance(content, PostableMarkdown)]
+        assert markdown_posts, "expected at least one PostableMarkdown post"
+        assert all(p.markdown.strip() for p in markdown_posts)
 
     # it("should not edit placeholder to empty during LLM warm-up")
     @pytest.mark.asyncio
@@ -453,9 +453,9 @@ async def test_should_not_edit_placeholder_to_empty_during_llm_warmup(self):
         text_stream = _create_text_stream(["Hello world"])
         await thread.post(text_stream)
 
-        for _, _, content in adapter._edit_calls:
-            if isinstance(content, PostableMarkdown):
-                assert len(content.markdown.strip()) > 0
+        markdown_edits = [content for _, _, content in adapter._edit_calls if isinstance(content, PostableMarkdown)]
+        assert markdown_edits, "expected at least one PostableMarkdown edit"
+        assert all(e.markdown.strip() for e in markdown_edits)
 
     # it("should not post empty content during streaming with whitespace chunks")
     @pytest.mark.asyncio
@@ -467,9 +467,9 @@ async def test_should_not_post_empty_content_during_streaming_with_whitespace_ch
         text_stream = _create_text_stream(["  ", "\n", "  \n"])
         await thread.post(text_stream)
 
-        for _, content in adapter._post_calls:
-            if isinstance(content, PostableMarkdown):
-                assert len(content.markdown) > 0
+        markdown_posts = [content for _, content in adapter._post_calls if isinstance(content, PostableMarkdown)]
+        assert markdown_posts, "expected at least one PostableMarkdown post"
+        assert all(len(p.markdown) > 0 for p in markdown_posts)
 
     # it("should preserve newlines in streamed text (native path)")
     @pytest.mark.asyncio