fix: address PR review comments on async transport foundation

- Use inspect.isawaitable() in future_utils for correct awaitable detection
- Guard async_mode=True with a clear AuthException when async client is not initialized
- Use contextvars.ContextVar for last_response in async methods (thread-safe per task)
- Add aclose() and __aenter__/__aexit__ to DescopeClient for async resource cleanup

Author: LioriE

descope/descope_client.py

@@ -115,6 +115,16 @@ def __init__(
         self._auth_http_client = auth_http_client
         self._mgmt_http_client = mgmt_http_client
 
+    async def aclose(self) -> None:
+        await self._auth_http_client.aclose()
+        await self._mgmt_http_client.aclose()
+
+    async def __aenter__(self):
+        return self
+
+    async def __aexit__(self, *_):
+        await self.aclose()
+
     @property
     def mgmt(self):
         return self._mgmt

descope/future_utils.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-import asyncio
+import inspect
 from typing import Any, Awaitable, Callable, TypeVar, Union
 
 T = TypeVar("T")
@@ -9,7 +9,7 @@
 def then(
     result_or_coro: Union[T, Awaitable[T]], modifier: Callable[[T], Any]
 ) -> Union[Any, Awaitable[Any]]:
-    if asyncio.iscoroutine(result_or_coro) or asyncio.isfuture(result_or_coro):
+    if inspect.isawaitable(result_or_coro):
 
         async def process_async():
             result = await result_or_coro
@@ -32,6 +32,6 @@ async def awaitable_wrapper():
 
 
 async def resolve(obj: Union[Any, Awaitable[Any]]) -> Any:
-    if asyncio.iscoroutine(obj) or asyncio.isfuture(obj):
+    if inspect.isawaitable(obj):
         return await obj
     return obj

descope/http_client.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import asyncio
+import contextvars
 import os
 import platform
 import ssl
@@ -178,6 +179,9 @@ def __init__(
         # Reserved for the future global async rollout (see big-plan.md "Final stage")
         self.async_mode_experimental = async_mode_experimental
         self._thread_local = threading.local()
+        self._async_last_response: contextvars.ContextVar[DescopeResponse | None] = contextvars.ContextVar(
+            "last_response", default=None
+        )
 
         # Setup SSL verification for httpx (backwards compatibility with requests)
         self.client_verify: bool | ssl.SSLContext = False
@@ -208,6 +212,8 @@ def get(
         async_mode: bool = False,
     ) -> httpx.Response | Awaitable[httpx.Response]:
         if async_mode:
+            if self._async_client is None:
+                raise AuthException(400, ERROR_TYPE_INVALID_ARGUMENT, "async_mode requires async_mode_experimental=True at client construction")
             return self._async_get(uri, params=params, allow_redirects=allow_redirects, pswd=pswd)
         response = self._execute_with_retry(
             lambda: httpx.get(
@@ -235,6 +241,8 @@ def post(
         async_mode: bool = False,
     ) -> httpx.Response | Awaitable[httpx.Response]:
         if async_mode:
+            if self._async_client is None:
+                raise AuthException(400, ERROR_TYPE_INVALID_ARGUMENT, "async_mode requires async_mode_experimental=True at client construction")
             return self._async_post(uri, body=body, params=params, pswd=pswd, base_url=base_url)
         response = self._execute_with_retry(
             lambda: httpx.post(
@@ -262,6 +270,8 @@ def put(
         async_mode: bool = False,
     ) -> httpx.Response | Awaitable[httpx.Response]:
         if async_mode:
+            if self._async_client is None:
+                raise AuthException(400, ERROR_TYPE_INVALID_ARGUMENT, "async_mode requires async_mode_experimental=True at client construction")
             return self._async_put(uri, body=body, params=params, pswd=pswd)
         response = self._execute_with_retry(
             lambda: httpx.put(
@@ -287,6 +297,8 @@ def patch(
         async_mode: bool = False,
     ) -> httpx.Response | Awaitable[httpx.Response]:
         if async_mode:
+            if self._async_client is None:
+                raise AuthException(400, ERROR_TYPE_INVALID_ARGUMENT, "async_mode requires async_mode_experimental=True at client construction")
             return self._async_patch(uri, body=body, params=params, pswd=pswd)
         response = self._execute_with_retry(
             lambda: httpx.patch(
@@ -313,6 +325,8 @@ def delete(
         async_mode: bool = False,
     ) -> httpx.Response | Awaitable[httpx.Response]:
         if async_mode:
+            if self._async_client is None:
+                raise AuthException(400, ERROR_TYPE_INVALID_ARGUMENT, "async_mode requires async_mode_experimental=True at client construction")
             return self._async_delete(uri, params=params, pswd=pswd)
         response = self._execute_with_retry(
             lambda: httpx.delete(
@@ -351,6 +365,9 @@ def get_last_response(self) -> DescopeResponse | None:
                 if resp:
                     logger.error(f"cf-ray: {resp.headers.get('cf-ray')}")
         """
+        async_resp = self._async_last_response.get(None)
+        if async_resp is not None:
+            return async_resp
         return getattr(self._thread_local, "last_response", None)
 
     def get_default_headers(self, pswd: str | None = None) -> dict:
@@ -460,7 +477,7 @@ async def _async_get(
             )
         )
         if self.verbose:
-            self._thread_local.last_response = DescopeResponse(response)
+            self._async_last_response.set(DescopeResponse(response))
         self._raise_from_response(response)
         return response
 
@@ -483,7 +500,7 @@ async def _async_post(
             )
         )
         if self.verbose:
-            self._thread_local.last_response = DescopeResponse(response)
+            self._async_last_response.set(DescopeResponse(response))
         self._raise_from_response(response)
         return response
 
@@ -525,7 +542,7 @@ async def _async_patch(
             )
         )
         if self.verbose:
-            self._thread_local.last_response = DescopeResponse(response)
+            self._async_last_response.set(DescopeResponse(response))
         self._raise_from_response(response)
         return response
 
@@ -545,6 +562,6 @@ async def _async_delete(
             )
         )
         if self.verbose:
-            self._thread_local.last_response = DescopeResponse(response)
+            self._async_last_response.set(DescopeResponse(response))
         self._raise_from_response(response)
         return response