fix(skills): resolve non-coroutine awaitables in resolve_response

`inspect.isawaitable()` also matches Tasks, Futures and custom `__await__`
types, while `asyncio.run()` takes a coroutine specifically — so a client
returning anything other than a raw coroutine raised "a coroutine was expected".
Wrap the awaitable instead, which also makes the two `type: ignore[arg-type]`
comments unnecessary.

Awaitables already bound to a running loop still raise, since resolving one
synchronously would block the loop it needs to progress; documented on the
function.

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

Author: joaomdmoura

lib/crewai/src/crewai/utilities/plus_client_factory.py

@@ -69,6 +69,11 @@ def resolve_response(response: Any) -> Any:
     ``PlusAPI`` is synchronous while the Enterprise client is asynchronous, so
     call sites accept either and normalize here.
 
+    Awaitables that are already bound to a running loop (a Task or Future) can't
+    be resolved this way and raise — resolving one synchronously would mean
+    blocking the very loop it needs to make progress. Clients should hand back
+    coroutines.
+
     Args:
         response: A response, or an awaitable resolving to one.
 
@@ -78,6 +83,12 @@ def resolve_response(response: Any) -> Any:
     if not inspect.isawaitable(response):
         return response
 
+    # asyncio.run() takes a coroutine specifically, while isawaitable() also
+    # covers Tasks, Futures and custom __await__ objects, so wrap rather than
+    # passing the awaitable straight through.
+    async def await_response() -> Any:
+        return await response
+
     try:
         loop = asyncio.get_running_loop()
     except RuntimeError:
@@ -87,6 +98,6 @@ def resolve_response(response: Any) -> Any:
     # to a worker thread with a loop of its own.
     if loop and loop.is_running():
         with concurrent.futures.ThreadPoolExecutor() as pool:
-            return pool.submit(asyncio.run, response).result()  # type: ignore[arg-type]
+            return pool.submit(asyncio.run, await_response()).result()
 
-    return asyncio.run(response)  # type: ignore[arg-type]
+    return asyncio.run(await_response())

lib/crewai/tests/utilities/test_plus_client_factory.py

@@ -104,3 +104,16 @@ async def main() -> Any:
             return resolve_response(call())
 
         assert asyncio.run(main()) is response
+
+    def test_awaits_a_non_coroutine_awaitable(self) -> None:
+        """isawaitable() also covers Tasks, Futures and custom __await__ types."""
+        response = MagicMock()
+
+        class Awaitable:
+            def __await__(self):  # noqa: ANN204
+                async def inner() -> Any:
+                    return response
+
+                return inner().__await__()
+
+        assert resolve_response(Awaitable()) is response