fix(adapters): align discord/linear/teams body extraction with working pattern

CodeRabbit flagged three real bugs in the discord/linear/teams
`_get_request_body` implementations that the github/telegram/whatsapp
fix didn't cover:

- `str(await result if ... else result)` wrong-stringifies bytes returned
  from a callable `request.text()` (e.g. `str(b"...") -> "b'...'"`).
- Non-callable `request.text` holding `bytes`/`bytearray` returns raw
  bytes to a `-> str` signature, typecheck lie + caller breaks.
- `data` fallback missed `bytearray` (matches the earlier text/body
  bytes-vs-bytearray fix).
- `read()` was only awaited via `iscoroutinefunction(raw_read)`, which
  misses wrapped/decorated methods that return an awaitable. Switched
  to `inspect.isawaitable(raw_result)` on the call result.

Restructured all three to match the text-first shape used by the static
adapters (github/telegram/whatsapp) and marked them `@staticmethod` —
`self` was unused and consistency avoids future regressions.

Tests: extended `test_request_body_extraction.py` matrix from 3 adapters
to 6 and added `test_handles_sync_callable_body` for the previously
unexercised sync body() branch. Dropped the broad `except ImportError:
pass` guard — every adapter lazy-imports platform deps inside methods,
so direct imports work and a broken adapter module now fails the suite
instead of silently skipping (matches the "every test must fail when
the code is wrong" rule).

54 parametrized cases (9 shapes × 6 adapters) — all passing.

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

Author: patrick-chinchill

src/chat_sdk/adapters/discord/adapter.py

@@ -1403,11 +1403,19 @@ async def _discord_fetch(
     # Request/Response helpers (framework-agnostic)
     # =========================================================================
 
-    async def _get_request_body(self, request: Any) -> str:
+    @staticmethod
+    async def _get_request_body(request: Any) -> str:
         """Extract the request body as a string."""
-        # `hasattr` narrows `Any` to `object` and kills downstream type info,
-        # so we use `getattr(..., default)` which preserves `Any`. The
-        # `await` below is safe because `inspect.isawaitable` guards it.
+        # `hasattr` narrows `Any` → `object` (not awaitable); using
+        # `getattr(..., None)` preserves `Any` for framework duck-typing.
+        # Handle both callable and non-callable `request.text`. Gating
+        # entry on callability would drop populated string attributes.
+        text_attr = getattr(request, "text", None)
+        if text_attr is not None:
+            if callable(text_attr):
+                result = text_attr()
+                text_attr = await result if inspect.isawaitable(result) else result
+            return text_attr.decode("utf-8") if isinstance(text_attr, (bytes, bytearray)) else str(text_attr)
         body = getattr(request, "body", None)
         if body is not None:
             if callable(body):
@@ -1417,19 +1425,13 @@ async def _get_request_body(self, request: Any) -> str:
             if inspect.isawaitable(body):
                 body = await body
             if hasattr(body, "read"):
-                raw_read = body.read
-                raw = await raw_read() if inspect.iscoroutinefunction(raw_read) else raw_read()
-                return raw.decode("utf-8") if isinstance(raw, (bytes, bytearray)) else raw
+                raw_result = body.read()
+                raw = await raw_result if inspect.isawaitable(raw_result) else raw_result
+                return raw.decode("utf-8") if isinstance(raw, (bytes, bytearray)) else str(raw)
             return body.decode("utf-8") if isinstance(body, (bytes, bytearray)) else str(body)
-        text_attr = getattr(request, "text", None)
-        if text_attr is not None:
-            if callable(text_attr):
-                result = text_attr()
-                return str(await result if inspect.isawaitable(result) else result)
-            return text_attr
         data = getattr(request, "data", None)
         if data is not None:
-            return data.decode("utf-8") if isinstance(data, bytes) else str(data)
+            return data.decode("utf-8") if isinstance(data, (bytes, bytearray)) else str(data)
         return ""
 
     def _get_header(self, request: Any, name: str) -> str | None:

src/chat_sdk/adapters/linear/adapter.py

@@ -978,11 +978,19 @@ async def _graphql_query(
     # Request/Response helpers (framework-agnostic)
     # =========================================================================
 
-    async def _get_request_body(self, request: Any) -> str:
+    @staticmethod
+    async def _get_request_body(request: Any) -> str:
         """Extract the request body as a string."""
-        # `hasattr` narrows `Any` → `object` (which is not awaitable); using
-        # `getattr(..., None)` preserves `Any` so the downstream `await` on
-        # framework-returned coroutines type-checks.
+        # `hasattr` narrows `Any` → `object` (not awaitable); using
+        # `getattr(..., None)` preserves `Any` for framework duck-typing.
+        # Handle both callable and non-callable `request.text`. Gating
+        # entry on callability would drop populated string attributes.
+        text_attr = getattr(request, "text", None)
+        if text_attr is not None:
+            if callable(text_attr):
+                result = text_attr()
+                text_attr = await result if inspect.isawaitable(result) else result
+            return text_attr.decode("utf-8") if isinstance(text_attr, (bytes, bytearray)) else str(text_attr)
         body = getattr(request, "body", None)
         if body is not None:
             if callable(body):
@@ -992,19 +1000,13 @@ async def _get_request_body(self, request: Any) -> str:
             if inspect.isawaitable(body):
                 body = await body
             if hasattr(body, "read"):
-                raw_read = body.read
-                raw = await raw_read() if inspect.iscoroutinefunction(raw_read) else raw_read()
-                return raw.decode("utf-8") if isinstance(raw, (bytes, bytearray)) else raw
+                raw_result = body.read()
+                raw = await raw_result if inspect.isawaitable(raw_result) else raw_result
+                return raw.decode("utf-8") if isinstance(raw, (bytes, bytearray)) else str(raw)
             return body.decode("utf-8") if isinstance(body, (bytes, bytearray)) else str(body)
-        text_attr = getattr(request, "text", None)
-        if text_attr is not None:
-            if callable(text_attr):
-                result = text_attr()
-                return str(await result if inspect.isawaitable(result) else result)
-            return text_attr
         data = getattr(request, "data", None)
         if data is not None:
-            return data.decode("utf-8") if isinstance(data, bytes) else str(data)
+            return data.decode("utf-8") if isinstance(data, (bytes, bytearray)) else str(data)
         return ""
 
     def _get_header(self, request: Any, name: str) -> str | None:

src/chat_sdk/adapters/teams/adapter.py

@@ -1768,10 +1768,19 @@ async def _verify_bot_framework_token(self, request: Any) -> Any | None:
     # Request/Response helpers (framework-agnostic)
     # =========================================================================
 
-    async def _get_request_body(self, request: Any) -> str:
+    @staticmethod
+    async def _get_request_body(request: Any) -> str:
         """Extract the request body as a string."""
         # `hasattr` narrows `Any` → `object` (not awaitable); using
         # `getattr(..., None)` preserves `Any` for framework duck-typing.
+        # Handle both callable and non-callable `request.text`. Gating
+        # entry on callability would drop populated string attributes.
+        text_attr = getattr(request, "text", None)
+        if text_attr is not None:
+            if callable(text_attr):
+                result = text_attr()
+                text_attr = await result if inspect.isawaitable(result) else result
+            return text_attr.decode("utf-8") if isinstance(text_attr, (bytes, bytearray)) else str(text_attr)
         body = getattr(request, "body", None)
         if body is not None:
             if callable(body):
@@ -1781,19 +1790,13 @@ async def _get_request_body(self, request: Any) -> str:
             if inspect.isawaitable(body):
                 body = await body
             if hasattr(body, "read"):
-                raw_read = body.read
-                raw = await raw_read() if inspect.iscoroutinefunction(raw_read) else raw_read()
-                return raw.decode("utf-8") if isinstance(raw, (bytes, bytearray)) else raw
+                raw_result = body.read()
+                raw = await raw_result if inspect.isawaitable(raw_result) else raw_result
+                return raw.decode("utf-8") if isinstance(raw, (bytes, bytearray)) else str(raw)
             return body.decode("utf-8") if isinstance(body, (bytes, bytearray)) else str(body)
-        text_attr = getattr(request, "text", None)
-        if text_attr is not None:
-            if callable(text_attr):
-                result = text_attr()
-                return str(await result if inspect.isawaitable(result) else result)
-            return text_attr
         data = getattr(request, "data", None)
         if data is not None:
-            return data.decode("utf-8") if isinstance(data, bytes) else str(data)
+            return data.decode("utf-8") if isinstance(data, (bytes, bytearray)) else str(data)
         return ""
 
     def _get_header(self, request: Any, name: str) -> str | None:

tests/test_request_body_extraction.py

@@ -124,36 +124,26 @@ def __init__(self, body: bytearray) -> None:
 def _adapters() -> list[tuple[str, Any]]:
     """Return (name, extractor) pairs for each adapter's body extraction.
 
-    Lazy imports because some adapters require platform deps (cryptography,
-    pynacl). If a dep isn't installed, that adapter is skipped.
+    Imported directly: every adapter lazy-imports its platform deps inside
+    methods, so module-level import works in any environment the test runs
+    in. A broken adapter module fails the suite — matching the repo rule
+    "every test must fail when the code is wrong."
     """
-    result: list[tuple[str, Any]] = []
-
-    # GitHub (static method)
-    try:
-        from chat_sdk.adapters.github.adapter import GitHubAdapter
-
-        result.append(("github", GitHubAdapter._get_request_body))
-    except ImportError:
-        pass  # Optional platform dep missing — skip this adapter's cases.
-
-    # Telegram (static method)
-    try:
-        from chat_sdk.adapters.telegram.adapter import TelegramAdapter
-
-        result.append(("telegram", TelegramAdapter._get_request_body))
-    except ImportError:
-        pass  # Optional platform dep missing — skip this adapter's cases.
-
-    # WhatsApp (static method)
-    try:
-        from chat_sdk.adapters.whatsapp.adapter import WhatsAppAdapter
-
-        result.append(("whatsapp", WhatsAppAdapter._get_request_body))
-    except ImportError:
-        pass  # Optional platform dep missing — skip this adapter's cases.
-
-    return result
+    from chat_sdk.adapters.discord.adapter import DiscordAdapter
+    from chat_sdk.adapters.github.adapter import GitHubAdapter
+    from chat_sdk.adapters.linear.adapter import LinearAdapter
+    from chat_sdk.adapters.teams.adapter import TeamsAdapter
+    from chat_sdk.adapters.telegram.adapter import TelegramAdapter
+    from chat_sdk.adapters.whatsapp.adapter import WhatsAppAdapter
+
+    return [
+        ("github", GitHubAdapter._get_request_body),
+        ("telegram", TelegramAdapter._get_request_body),
+        ("whatsapp", WhatsAppAdapter._get_request_body),
+        ("discord", DiscordAdapter._get_request_body),
+        ("linear", LinearAdapter._get_request_body),
+        ("teams", TeamsAdapter._get_request_body),
+    ]
 
 
 @pytest.mark.parametrize("name,extractor", _adapters())
@@ -207,6 +197,17 @@ async def test_handles_async_callable_body(name: str, extractor: Any) -> None:
     assert result == '{"ok": true}', f"{name} failed async body()"
 
 
+@pytest.mark.parametrize("name,extractor", _adapters())
+async def test_handles_sync_callable_body(name: str, extractor: Any) -> None:
+    """Sync `def body(self)` returning bytes is consumed directly —
+    covers the callable-but-non-awaitable body branch. Without this,
+    a regression that always awaits `body()` would only show up in
+    async-framework use and silently pass the suite.
+    """
+    result = await extractor(_SyncCallableBodyRequest(b'{"ok": true}'))
+    assert result == '{"ok": true}', f"{name} failed sync body()"
+
+
 @pytest.mark.parametrize("name,extractor", _adapters())
 async def test_handles_bytes_body_attribute(name: str, extractor: Any) -> None:
     """`request.body` as a bytes property is decoded as UTF-8."""