Framework for orchestrating role-playing, autonomous AI agents. By fostering collaborative intelligence, CrewAI empowers agents to work together seamlessly, tackling complex tasks.
fix: ensure async methods are executable for annotations
Greyson LaLondec59173a762c7
diff --git a/lib/crewai/src/crewai/project/annotations.py b/lib/crewai/src/crewai/project/annotations.pyindex a36999052..160359540 100644--- a/lib/crewai/src/crewai/project/annotations.py+++ b/lib/crewai/src/crewai/project/annotations.py@@ -2,8 +2,10 @@from __future__ import annotations+import asynciofrom collections.abc import Callablefrom functools import wraps+import inspectfrom typing import TYPE_CHECKING, Any, Concatenate, ParamSpec, TypeVar, overloadfrom crewai.project.utils import memoize@@ -156,6 +158,23 @@ def cache_handler(meth: Callable[P, R]) -> CacheHandlerMethod[P, R]:return CacheHandlerMethod(memoize(meth))+def _call_method(method: Callable[..., Any], *args: Any, **kwargs: Any) -> Any:+ """Call a method, awaiting it if async and running in an event loop."""+ result = method(*args, **kwargs)+ if inspect.iscoroutine(result):+ try:+ loop = asyncio.get_running_loop()+ except RuntimeError:+ loop = None+ if loop and loop.is_running():+ import concurrent.futures++ with concurrent.futures.ThreadPoolExecutor() as pool:+ return pool.submit(asyncio.run, result).result()+ return asyncio.run(result)+ return result++@overloaddef crew(meth: Callable[Concatenate[SelfT, P], Crew],@@ -198,7 +217,7 @@ def crew(# Instantiate tasks in orderfor _, task_method in tasks:- task_instance = task_method(self)+ task_instance = _call_method(task_method, self)instantiated_tasks.append(task_instance)agent_instance = getattr(task_instance, "agent", None)if agent_instance and agent_instance.role not in agent_roles:@@ -207,7 +226,7 @@ def crew(# Instantiate agents not included by tasksfor _, agent_method in agents:- agent_instance = agent_method(self)+ agent_instance = _call_method(agent_method, self)if agent_instance.role not in agent_roles:instantiated_agents.append(agent_instance)agent_roles.add(agent_instance.role)@@ -215,7 +234,7 @@ def crew(self.agents = instantiated_agentsself.tasks = instantiated_tasks- crew_instance = meth(self, *args, **kwargs)+ crew_instance: Crew = _call_method(meth, self, *args, **kwargs)def callback_wrapper(hook: Callable[Concatenate[CrewInstance, P2], R2], instance: CrewInstancediff --git a/lib/crewai/src/crewai/project/utils.py b/lib/crewai/src/crewai/project/utils.pyindex eae363b0d..b46a4dc44 100644--- a/lib/crewai/src/crewai/project/utils.py+++ b/lib/crewai/src/crewai/project/utils.py@@ -1,7 +1,8 @@"""Utility functions for the crewai project module."""-from collections.abc import Callable+from collections.abc import Callable, Coroutinefrom functools import wraps+import inspectfrom typing import Any, ParamSpec, TypeVar, castfrom pydantic import BaseModel@@ -37,8 +38,8 @@ def _make_hashable(arg: Any) -> Any:def memoize(meth: Callable[P, R]) -> Callable[P, R]:"""Memoize a method by caching its results based on arguments.- Handles Pydantic BaseModel instances by converting them to JSON strings- before hashing for cache lookup.+ Handles both sync and async methods. Pydantic BaseModel instances are+ converted to JSON strings before hashing for cache lookup.Args:meth: The method to memoize.@@ -46,18 +47,16 @@ def memoize(meth: Callable[P, R]) -> Callable[P, R]:Returns:A memoized version of the method that caches results."""+ if inspect.iscoroutinefunction(meth):+ return cast(Callable[P, R], _memoize_async(meth))+ return _memoize_sync(meth)- @wraps(meth)- def wrapper(*args: P.args, **kwargs: P.kwargs) -> R:- """Wrapper that converts arguments to hashable form before caching.- Args:- *args: Positional arguments to the memoized method.- **kwargs: Keyword arguments to the memoized method.+def _memoize_sync(meth: Callable[P, R]) -> Callable[P, R]:+ """Memoize a synchronous method."""- Returns:- The result of the memoized method call.- """+ @wraps(meth)+ def wrapper(*args: P.args, **kwargs: P.kwargs) -> R:hashable_args = tuple(_make_hashable(arg) for arg in args)hashable_kwargs = tuple(sorted((k, _make_hashable(v)) for k, v in kwargs.items())@@ -73,3 +72,27 @@ def memoize(meth: Callable[P, R]) -> Callable[P, R]:return resultreturn cast(Callable[P, R], wrapper)+++def _memoize_async(+ meth: Callable[P, Coroutine[Any, Any, R]],+) -> Callable[P, Coroutine[Any, Any, R]]:+ """Memoize an async method."""++ @wraps(meth)+ async def wrapper(*args: P.args, **kwargs: P.kwargs) -> R:+ hashable_args = tuple(_make_hashable(arg) for arg in args)+ hashable_kwargs = tuple(+ sorted((k, _make_hashable(v)) for k, v in kwargs.items())+ )+ cache_key = str((hashable_args, hashable_kwargs))++ cached_result: R | None = cache.read(tool=meth.__name__, input=cache_key)+ if cached_result is not None:+ return cached_result++ result = await meth(*args, **kwargs)+ cache.add(tool=meth.__name__, input=cache_key, output=result)+ return result++ return wrapperdiff --git a/lib/crewai/src/crewai/project/wrappers.py b/lib/crewai/src/crewai/project/wrappers.pyindex bfe28aa22..28cd39525 100644--- a/lib/crewai/src/crewai/project/wrappers.py+++ b/lib/crewai/src/crewai/project/wrappers.py@@ -2,8 +2,10 @@from __future__ import annotations+import asynciofrom collections.abc import Callablefrom functools import partial+import inspectfrom pathlib import Pathfrom typing import (TYPE_CHECKING,@@ -132,6 +134,22 @@ class CrewClass(Protocol):crew: Callable[..., Crew]+def _resolve_result(result: Any) -> Any:+ """Resolve a potentially async result to its value."""+ if inspect.iscoroutine(result):+ try:+ loop = asyncio.get_running_loop()+ except RuntimeError:+ loop = None+ if loop and loop.is_running():+ import concurrent.futures++ with concurrent.futures.ThreadPoolExecutor() as pool:+ return pool.submit(asyncio.run, result).result()+ return asyncio.run(result)+ return result++class DecoratedMethod(Generic[P, R]):"""Base wrapper for methods with decorator metadata.@@ -162,7 +180,12 @@ class DecoratedMethod(Generic[P, R]):"""if obj is None:return self- bound = partial(self._meth, obj)+ inner = partial(self._meth, obj)++ def _bound(*args: Any, **kwargs: Any) -> R:+ result: R = _resolve_result(inner(*args, **kwargs)) # type: ignore[call-arg]+ return result+for attr in ("is_agent","is_llm",@@ -174,8 +197,8 @@ class DecoratedMethod(Generic[P, R]):"is_crew",):if hasattr(self, attr):- setattr(bound, attr, getattr(self, attr))- return bound+ setattr(_bound, attr, getattr(self, attr))+ return _bounddef __call__(self, *args: P.args, **kwargs: P.kwargs) -> R:"""Call the wrapped method.@@ -236,6 +259,7 @@ class BoundTaskMethod(Generic[TaskResultT]):The task result with name ensured."""result = self._task_method.unwrap()(self._obj, *args, **kwargs)+ result = _resolve_result(result)return self._task_method.ensure_task_name(result)@@ -292,7 +316,9 @@ class TaskMethod(Generic[P, TaskResultT]):Returns:The task instance with name set if not already provided."""- return self.ensure_task_name(self._meth(*args, **kwargs))+ result = self._meth(*args, **kwargs)+ result = _resolve_result(result)+ return self.ensure_task_name(result)def unwrap(self) -> Callable[P, TaskResultT]:"""Get the original unwrapped method.diff --git a/lib/crewai/tests/test_project.py b/lib/crewai/tests/test_project.pyindex ebc3dfb82..33cf228f7 100644--- a/lib/crewai/tests/test_project.py+++ b/lib/crewai/tests/test_project.py@@ -272,6 +272,99 @@ def another_simple_tool():return "Hi!"+class TestAsyncDecoratorSupport:+ """Tests for async method support in @agent, @task decorators."""++ def test_async_agent_memoization(self):+ """Async agent methods should be properly memoized."""++ class AsyncAgentCrew:+ call_count = 0++ @agent+ async def async_agent(self):+ AsyncAgentCrew.call_count += 1+ return Agent(+ role="Async Agent", goal="Async Goal", backstory="Async Backstory"+ )++ crew = AsyncAgentCrew()+ first_call = crew.async_agent()+ second_call = crew.async_agent()++ assert first_call is second_call, "Async agent memoization failed"+ assert AsyncAgentCrew.call_count == 1, "Async agent called more than once"++ def test_async_task_memoization(self):+ """Async task methods should be properly memoized."""++ class AsyncTaskCrew:+ call_count = 0++ @task+ async def async_task(self):+ AsyncTaskCrew.call_count += 1+ return Task(+ description="Async Description", expected_output="Async Output"+ )++ crew = AsyncTaskCrew()+ first_call = crew.async_task()+ second_call = crew.async_task()++ assert first_call is second_call, "Async task memoization failed"+ assert AsyncTaskCrew.call_count == 1, "Async task called more than once"++ def test_async_task_name_inference(self):+ """Async task should have name inferred from method name."""++ class AsyncTaskNameCrew:+ @task+ async def my_async_task(self):+ return Task(+ description="Async Description", expected_output="Async Output"+ )++ crew = AsyncTaskNameCrew()+ task_instance = crew.my_async_task()++ assert task_instance.name == "my_async_task", (+ "Async task name not inferred correctly"+ )++ def test_async_agent_returns_agent_not_coroutine(self):+ """Async agent decorator should return Agent, not coroutine."""++ class AsyncAgentTypeCrew:+ @agent+ async def typed_async_agent(self):+ return Agent(+ role="Typed Agent", goal="Typed Goal", backstory="Typed Backstory"+ )++ crew = AsyncAgentTypeCrew()+ result = crew.typed_async_agent()++ assert isinstance(result, Agent), (+ f"Expected Agent, got {type(result).__name__}"+ )++ def test_async_task_returns_task_not_coroutine(self):+ """Async task decorator should return Task, not coroutine."""++ class AsyncTaskTypeCrew:+ @task+ async def typed_async_task(self):+ return Task(+ description="Typed Description", expected_output="Typed Output"+ )++ crew = AsyncTaskTypeCrew()+ result = crew.typed_async_task()++ assert isinstance(result, Task), f"Expected Task, got {type(result).__name__}"++def test_internal_crew_with_mcp():from crewai_tools.adapters.tool_collection import ToolCollection