agno 1.7.3__py3-none-any.whl → 1.7.5__py3-none-any.whl

agno/team/team.py

@@ -112,6 +112,9 @@ class Team:
     parent_team_id: Optional[str] = None
     # The workflow this team belongs to
     workflow_id: Optional[str] = None
+    # Set when this team is part of a workflow.
+    workflow_session_id: Optional[str] = None
+
     role: Optional[str] = None
 
     # --- User settings ---
@@ -127,9 +130,13 @@ class Team:
     session_name: Optional[str] = None
     # Session state (stored in the database to persist across runs)
     session_state: Optional[Dict[str, Any]] = None
+    # If True, cache the session in memory
+    cache_session: bool = True
 
     # Team session state (shared between team leaders and team members)
     team_session_state: Optional[Dict[str, Any]] = None
+    workflow_session_state: Optional[Dict[str, Any]] = None
+
     # If True, add the session state variables in the user and system messages
     add_state_in_messages: bool = False
 
@@ -304,7 +311,9 @@ class Team:
         session_name: Optional[str] = None,
         session_state: Optional[Dict[str, Any]] = None,
         team_session_state: Optional[Dict[str, Any]] = None,
+        workflow_session_state: Optional[Dict[str, Any]] = None,
         add_state_in_messages: bool = False,
+        cache_session: bool = True,
         description: Optional[str] = None,
         instructions: Optional[Union[str, List[str], Callable]] = None,
         expected_output: Optional[str] = None,
@@ -381,8 +390,11 @@ class Team:
         self.session_name = session_name
         self.session_state = session_state
         self.team_session_state = team_session_state
+        self.workflow_session_state = workflow_session_state
         self.add_state_in_messages = add_state_in_messages
 
+        self.cache_session = cache_session
+
         self.description = description
         self.instructions = instructions
         self.expected_output = expected_output
@@ -472,7 +484,7 @@ class Team:
         self.full_team_session_metrics: Optional[SessionMetrics] = None
 
         self.run_id: Optional[str] = None
-        self.run_input: Optional[Union[str, List, Dict]] = None
+        self.run_input: Optional[Union[str, List, Dict, BaseModel]] = None
         self.run_messages: Optional[RunMessages] = None
         self.run_response: Optional[TeamRunResponse] = None
 
@@ -549,6 +561,12 @@ class Team:
             else:
                 merge_dictionaries(member.team_session_state, self.team_session_state)
 
+        if self.workflow_session_state is not None:
+            if member.workflow_session_state is None:
+                member.workflow_session_state = self.workflow_session_state
+            else:
+                merge_dictionaries(member.workflow_session_state, self.workflow_session_state)
+
         if isinstance(member, Agent):
             member.team_id = self.team_id
             member.set_agent_id()
@@ -587,6 +605,8 @@ class Team:
 
     def _reset_session(self) -> None:
         self.session_name = None
+        self.session_state = None
+        self.team_session_state = None
         self.session_metrics = None
         self.session_state = None
         self.images = None
@@ -658,11 +678,15 @@ class Team:
             self.session_state["current_user_id"] = user_id
             if self.team_session_state is not None:
                 self.team_session_state["current_user_id"] = user_id
+            if self.workflow_session_state is not None:
+                self.workflow_session_state["current_user_id"] = user_id
 
         if session_id is not None:
             self.session_state["current_session_id"] = session_id
             if self.team_session_state is not None:
                 self.team_session_state["current_session_id"] = session_id
+            if self.workflow_session_state is not None:
+                self.workflow_session_state["current_user_id"] = user_id
 
     def _reset_session_state(self) -> None:
         """Reset the session state for the agent."""
@@ -710,15 +734,12 @@ class Team:
 
         self._initialize_session_state(user_id=user_id, session_id=session_id)
 
-        # Read existing session from storage
-        self.read_from_storage(session_id=session_id)
-
         return session_id, user_id
 
     @overload
     def run(
         self,
-        message: Union[str, List, Dict, Message],
+        message: Union[str, List, Dict, Message, BaseModel],
         *,
         stream: Literal[False] = False,
         stream_intermediate_steps: Optional[bool] = None,
@@ -737,7 +758,7 @@ class Team:
     @overload
     def run(
         self,
-        message: Union[str, List, Dict, Message],
+        message: Union[str, List, Dict, Message, BaseModel],
         *,
         stream: Literal[True] = True,
         stream_intermediate_steps: Optional[bool] = None,
@@ -755,7 +776,7 @@ class Team:
 
     def run(
         self,
-        message: Union[str, List, Dict, Message],
+        message: Union[str, List, Dict, Message, BaseModel],
         *,
         stream: Optional[bool] = None,
         stream_intermediate_steps: Optional[bool] = None,
@@ -780,6 +801,9 @@ class Team:
         # Initialize Team
         self.initialize_team(session_id=session_id)
 
+        # Read existing session from storage
+        self.read_from_storage(session_id=session_id)
+
         # Initialize Knowledge Filters
         effective_filters = knowledge_filters
 
@@ -1119,7 +1143,7 @@ class Team:
     @overload
     async def arun(
         self,
-        message: Union[str, List, Dict, Message],
+        message: Union[str, List, Dict, Message, BaseModel],
         *,
         stream: Literal[False] = False,
         stream_intermediate_steps: Optional[bool] = None,
@@ -1138,7 +1162,7 @@ class Team:
     @overload
     async def arun(
         self,
-        message: Union[str, List, Dict, Message],
+        message: Union[str, List, Dict, Message, BaseModel],
         *,
         stream: Literal[True] = True,
         stream_intermediate_steps: Optional[bool] = None,
@@ -1156,7 +1180,7 @@ class Team:
 
     async def arun(
         self,
-        message: Union[str, List, Dict, Message],
+        message: Union[str, List, Dict, Message, BaseModel],
         *,
         stream: Optional[bool] = None,
         stream_intermediate_steps: Optional[bool] = None,
@@ -1172,14 +1196,17 @@ class Team:
         **kwargs: Any,
     ) -> Union[TeamRunResponse, AsyncIterator[Union[RunResponseEvent, TeamRunResponseEvent]]]:
         """Run the Team asynchronously and return the response."""
-
         session_id, user_id = self._initialize_session(
             session_id=session_id, user_id=user_id, session_state=session_state
         )
         log_debug(f"Session ID: {session_id}", center=True)
 
+        # Initialize Team
         self.initialize_team(session_id=session_id)
 
+        # Read existing session from storage
+        self.read_from_storage(session_id=session_id)
+
         effective_filters = knowledge_filters
 
         # When filters are passed manually
@@ -1611,7 +1638,7 @@ class Team:
             self.memory.add_team_run(team_run)  # type: ignore
 
         elif isinstance(self.memory, Memory):
-            # Add AgentRun to memory
+            # Add run to memory
             self.memory.add_run(session_id=session_id, run=run_response)
 
     def _update_memory(
@@ -2388,7 +2415,7 @@ class Team:
 
     def print_response(
         self,
-        message: Optional[Union[List, Dict, str, Message]] = None,
+        message: Optional[Union[List, Dict, str, Message, BaseModel]] = None,
         *,
         stream: bool = False,
         stream_intermediate_steps: bool = False,
@@ -2458,7 +2485,7 @@ class Team:
 
     def _print_response(
         self,
-        message: Optional[Union[List, Dict, str, Message]] = None,
+        message: Optional[Union[List, Dict, str, Message, BaseModel]] = None,
         console: Optional[Any] = None,
         show_message: bool = True,
         show_reasoning: bool = True,
@@ -2742,7 +2769,7 @@ class Team:
 
     def _print_response_stream(
         self,
-        message: Optional[Union[List, Dict, str, Message]] = None,
+        message: Optional[Union[List, Dict, str, Message, BaseModel]] = None,
         console: Optional[Any] = None,
         show_message: bool = True,
         show_reasoning: bool = True,
@@ -3259,7 +3286,7 @@ class Team:
 
     async def aprint_response(
         self,
-        message: Optional[Union[List, Dict, str, Message]] = None,
+        message: Optional[Union[List, Dict, str, Message, BaseModel]] = None,
         *,
         stream: bool = False,
         stream_intermediate_steps: bool = False,
@@ -3329,7 +3356,7 @@ class Team:
 
     async def _aprint_response(
         self,
-        message: Optional[Union[List, Dict, str, Message]] = None,
+        message: Optional[Union[List, Dict, str, Message, BaseModel]] = None,
         console: Optional[Any] = None,
         show_message: bool = True,
         show_reasoning: bool = True,
@@ -3611,7 +3638,7 @@ class Team:
 
     async def _aprint_response_stream(
         self,
-        message: Optional[Union[List, Dict, str, Message]] = None,
+        message: Optional[Union[List, Dict, str, Message, BaseModel]] = None,
         console: Optional[Any] = None,
         show_message: bool = True,
         show_reasoning: bool = True,
@@ -4803,7 +4830,7 @@ class Team:
         user_id: Optional[str] = None,
         async_mode: bool = False,
         knowledge_filters: Optional[Dict[str, Any]] = None,
-        message: Optional[Union[str, List, Dict, Message]] = None,
+        message: Optional[Union[str, List, Dict, Message, BaseModel]] = None,
         images: Optional[Sequence[Image]] = None,
         videos: Optional[Sequence[Video]] = None,
         audio: Optional[Sequence[Audio]] = None,
@@ -5299,7 +5326,7 @@ class Team:
         *,
         session_id: str,
         user_id: Optional[str] = None,
-        message: Optional[Union[str, List, Dict, Message]] = None,
+        message: Optional[Union[str, List, Dict, Message, BaseModel]] = None,
         audio: Optional[Sequence[Audio]] = None,
         images: Optional[Sequence[Image]] = None,
         videos: Optional[Sequence[Video]] = None,
@@ -5381,7 +5408,7 @@ class Team:
 
     def _get_user_message(
         self,
-        message: Optional[Union[str, List, Dict, Message]] = None,
+        message: Optional[Union[str, List, Dict, Message, BaseModel]] = None,
         user_id: Optional[str] = None,
         audio: Optional[Sequence[Audio]] = None,
         images: Optional[Sequence[Image]] = None,
@@ -5399,6 +5426,8 @@ class Team:
                 message_str = message
             elif callable(message):
                 message_str = message(agent=self)
+            elif isinstance(message, BaseModel):
+                message_str = message.model_dump_json(indent=2, exclude_none=True)
             else:
                 raise Exception("message must be a string or a callable when add_references is True")
 
@@ -5544,6 +5573,7 @@ class Team:
         format_variables = ChainMap(
             self.session_state or {},
             self.team_session_state or {},
+            self.workflow_session_state or {},
             self.context or {},
             self.extra_data or {},
             {"user_id": user_id} if user_id is not None else {},
@@ -5816,6 +5846,23 @@ class Team:
             else:
                 merge_dictionaries(self.team_session_state, member_agent.team_session_state)
 
+    def _update_workflow_session_state(self, member_agent: Union[Agent, "Team"]) -> None:
+        """Update workflow session state from either an Agent or nested Team member"""
+        # Get member state safely
+        member_state = getattr(member_agent, "workflow_session_state", None)
+
+        # Only proceed if member has valid state
+        if member_state is not None and isinstance(member_state, dict):
+            # Initialize team state if needed
+            if self.workflow_session_state is None:
+                self.workflow_session_state = {}
+
+            # Only merge if both are dictionaries and member state is not empty
+            if isinstance(self.workflow_session_state, dict) and member_state:
+                from agno.utils.merge_dict import merge_dictionaries
+
+                merge_dictionaries(self.workflow_session_state, member_state)
+
     def get_run_member_agents_function(
         self,
         session_id: str,
@@ -5944,6 +5991,8 @@ class Team:
                 # Update team session state
                 self._update_team_session_state(member_agent)
 
+                self._update_workflow_session_state(member_agent)
+
                 # Update the team media
                 self._update_team_media(member_agent.run_response)  # type: ignore
 
@@ -6023,6 +6072,8 @@ class Team:
                     # Update team session state
                     self._update_team_session_state(current_agent)
 
+                    self._update_workflow_session_state(current_agent)
+
                     # Update the team media
                     self._update_team_media(agent.run_response)
 
@@ -6259,6 +6310,8 @@ class Team:
             # Update team session state
             self._update_team_session_state(member_agent)
 
+            self._update_workflow_session_state(member_agent)
+
             # Update the team media
             self._update_team_media(member_agent.run_response)  # type: ignore
 
@@ -6389,6 +6442,8 @@ class Team:
             # Update team session state
             self._update_team_session_state(member_agent)
 
+            self._update_workflow_session_state(member_agent)
+
             # Update the team media
             self._update_team_media(member_agent.run_response)  # type: ignore
 
@@ -6627,6 +6682,8 @@ class Team:
             # Update team session state
             self._update_team_session_state(member_agent)
 
+            self._update_workflow_session_state(member_agent)
+
             # Update the team media
             self._update_team_media(member_agent.run_response)  # type: ignore
 
@@ -6756,6 +6813,8 @@ class Team:
             # Update team session state
             self._update_team_session_state(member_agent)
 
+            self._update_workflow_session_state(member_agent)
+
             # Update the team media
             self._update_team_media(member_agent.run_response)  # type: ignore
 
@@ -6797,6 +6856,11 @@ class Team:
             self.team_session = cast(
                 TeamSession, self.storage.upsert(session=self._get_team_session(session_id=session_id, user_id=user_id))
             )
+
+        # Remove session from memory
+        if not self.cache_session:
+            if self.memory is not None and self.memory.runs is not None and session_id in self.memory.runs:
+                self.memory.runs.pop(session_id)  # type: ignore
         return self.team_session
 
     def rename_session(self, session_name: str, session_id: Optional[str] = None) -> None:
@@ -6872,6 +6936,20 @@ class Team:
                     # Update the current team_session_state
                     self.team_session_state = team_session_state_from_db
 
+            if "workflow_session_state" in session.session_data:
+                workflow_session_state_from_db = session.session_data.get("workflow_session_state")
+                if (
+                    workflow_session_state_from_db is not None
+                    and isinstance(workflow_session_state_from_db, dict)
+                    and len(workflow_session_state_from_db) > 0
+                ):
+                    # If the workflow_session_state is already set, merge the workflow_session_state from the database with the current workflow_session_state
+                    if self.workflow_session_state is not None and len(self.workflow_session_state) > 0:
+                        # This updates workflow_session_state_from_db
+                        merge_dictionaries(workflow_session_state_from_db, self.workflow_session_state)
+                    # Update the current workflow_session_state
+                    self.workflow_session_state = workflow_session_state_from_db
+
             # Get the session_metrics from the database
             if "session_metrics" in session.session_data:
                 session_metrics_from_db = session.session_data.get("session_metrics")
@@ -6960,6 +7038,7 @@ class Team:
                         self.memory.runs[session.session_id] = []
                         for run in session.memory["runs"]:
                             run_session_id = run["session_id"]
+
                             if "team_id" in run:
                                 self.memory.runs[run_session_id].append(TeamRunResponse.from_dict(run))
                             else:
@@ -7645,6 +7724,8 @@ class Team:
             session_data["session_state"] = self.session_state
         if self.team_session_state is not None and len(self.team_session_state) > 0:
             session_data["team_session_state"] = self.team_session_state
+        if self.workflow_session_state is not None and len(self.workflow_session_state) > 0:
+            session_data["workflow_session_state"] = self.workflow_session_state
         if self.session_metrics is not None:
             session_data["session_metrics"] = asdict(self.session_metrics) if self.session_metrics is not None else None
         if self.images is not None:
@@ -7672,11 +7753,13 @@ class Team:
                     run_responses = self.memory.runs.get(session_id)
                     if run_responses is not None:
                         memory_dict["runs"] = [rr.to_dict() for rr in run_responses]
+
         return TeamSession(
             session_id=session_id,
             team_id=self.team_id,
             user_id=user_id,
             team_session_id=self.team_session_id,
+            workflow_session_id=self.workflow_session_id,
             memory=memory_dict,
             team_data=self._get_team_data(),
             session_data=self._get_session_data(),
@@ -7701,6 +7784,7 @@ class Team:
                     run_id=self.run_id,  # type: ignore
                     run_data=run_data,
                     team_session_id=team_session.team_session_id,
+                    workflow_session_id=self.workflow_session_id,
                     session_id=team_session.session_id,
                     team_data=team_session.to_dict() if self.monitoring else team_session.telemetry_data(),
                 ),

agno/tools/decorator.py

@@ -9,6 +9,49 @@ F = TypeVar("F", bound=Callable[..., Any])
 ToolConfig = TypeVar("ToolConfig", bound=Dict[str, Any])
 
 
+def _is_async_function(func: Callable) -> bool:
+    """
+    Check if a function is async, even when wrapped by decorators like @staticmethod.
+
+    This function tries to detect async functions by:
+    1. Checking the function directly with inspect functions
+    2. Looking at the original function if it's wrapped
+    3. Checking the function's code object for async indicators
+    """
+    from inspect import iscoroutine, iscoroutinefunction
+
+    # First, try the standard inspect functions
+    if iscoroutinefunction(func) or iscoroutine(func):
+        return True
+
+    # If the function has a __wrapped__ attribute, check the original function
+    if hasattr(func, "__wrapped__"):
+        original_func = func.__wrapped__
+        if iscoroutinefunction(original_func) or iscoroutine(original_func):
+            return True
+
+    # Check if the function has CO_COROUTINE flag in its code object
+    try:
+        if hasattr(func, "__code__") and func.__code__.co_flags & 0x80:  # CO_COROUTINE flag
+            return True
+    except (AttributeError, TypeError):
+        pass
+
+    # For static methods, try to get the original function
+    try:
+        if hasattr(func, "__func__"):
+            original_func = func.__func__
+            if iscoroutinefunction(original_func) or iscoroutine(original_func):
+                return True
+            # Check the code object of the original function
+            if hasattr(original_func, "__code__") and original_func.__code__.co_flags & 0x80:
+                return True
+    except (AttributeError, TypeError):
+        pass
+
+    return False
+
+
 @overload
 def tool() -> Callable[[F], Function]: ...
 
@@ -125,7 +168,7 @@ def tool(*args, **kwargs) -> Union[Function, Callable[[F], Function]]:
         )
 
     def decorator(func: F) -> Function:
-        from inspect import isasyncgenfunction, iscoroutine, iscoroutinefunction
+        from inspect import isasyncgenfunction
 
         @wraps(func)
         def sync_wrapper(*args: Any, **kwargs: Any) -> Any:
@@ -163,7 +206,7 @@ def tool(*args, **kwargs) -> Union[Function, Callable[[F], Function]]:
         # Choose appropriate wrapper based on function type
         if isasyncgenfunction(func):
             wrapper = async_gen_wrapper
-        elif iscoroutinefunction(func) or iscoroutine(func):
+        elif _is_async_function(func):
             wrapper = async_wrapper
         else:
             wrapper = sync_wrapper

agno/tools/function.py

@@ -151,7 +151,7 @@ class Function(BaseModel):
             param_type_hints = {
                 name: type_hints.get(name)
                 for name in sig.parameters
-                if name != "return" and name not in ["agent", "team"]
+                if name != "return" and name not in ["agent", "team", "self"]
             }
 
             # Parse docstring for parameters
@@ -177,7 +177,9 @@ class Function(BaseModel):
             # If strict=True mark all fields as required
             # See: https://platform.openai.com/docs/guides/structured-outputs/supported-schemas#all-fields-must-be-required
             if strict:
-                parameters["required"] = [name for name in parameters["properties"] if name not in ["agent", "team"]]
+                parameters["required"] = [
+                    name for name in parameters["properties"] if name not in ["agent", "team", "self"]
+                ]
             else:
                 # Mark a field as required if it has no default value (this would include optional fields)
                 parameters["required"] = [
@@ -235,7 +237,7 @@ class Function(BaseModel):
             # log_info(f"Type hints for {self.name}: {type_hints}")
 
             # Filter out return type and only process parameters
-            excluded_params = ["return", "agent", "team"]
+            excluded_params = ["return", "agent", "team", "self"]
             if self.requires_user_input and self.user_input_fields:
                 if len(self.user_input_fields) == 0:
                     excluded_params.extend(list(type_hints.keys()))
@@ -337,7 +339,9 @@ class Function(BaseModel):
 
     def process_schema_for_strict(self):
         self.parameters["additionalProperties"] = False
-        self.parameters["required"] = [name for name in self.parameters["properties"] if name not in ["agent", "team"]]
+        self.parameters["required"] = [
+            name for name in self.parameters["properties"] if name not in ["agent", "team", "self"]
+        ]
 
     def _get_cache_key(self, entrypoint_args: Dict[str, Any], call_args: Optional[Dict[str, Any]] = None) -> str:
         """Generate a cache key based on function name and arguments."""
@@ -554,7 +558,7 @@ class FunctionCall(BaseModel):
         from functools import reduce
         from inspect import iscoroutinefunction
 
-        def execute_entrypoint():
+        def execute_entrypoint(name, func, args):
             """Execute the entrypoint function."""
             arguments = entrypoint_args.copy()
             if self.arguments is not None:
@@ -572,9 +576,9 @@ class FunctionCall(BaseModel):
                 # Pass the inner function as next_func to the hook
                 # The hook will call next_func to continue the chain
                 def next_func(**kwargs):
-                    return inner_func()
+                    return inner_func(name, func, kwargs)
 
-                hook_args = self._build_hook_args(hook, name, func, args)
+                hook_args = self._build_hook_args(hook, name, next_func, args)
 
                 return hook(**hook_args)
 
@@ -716,7 +720,7 @@ class FunctionCall(BaseModel):
         from functools import reduce
         from inspect import isasyncgen, isasyncgenfunction, iscoroutinefunction
 
-        async def execute_entrypoint_async():
+        async def execute_entrypoint_async(name, func, args):
             """Execute the entrypoint function asynchronously."""
             arguments = entrypoint_args.copy()
             if self.arguments is not None:
@@ -729,7 +733,7 @@ class FunctionCall(BaseModel):
                 result = await result
             return result
 
-        def execute_entrypoint():
+        def execute_entrypoint(name, func, args):
             """Execute the entrypoint function synchronously."""
             arguments = entrypoint_args.copy()
             if self.arguments is not None:
@@ -750,11 +754,11 @@ class FunctionCall(BaseModel):
                 # The hook will call next_func to continue the chain
                 async def next_func(**kwargs):
                     if iscoroutinefunction(inner_func):
-                        return await inner_func()
+                        return await inner_func(name, func, kwargs)
                     else:
-                        return inner_func()
+                        return inner_func(name, func, kwargs)
 
-                hook_args = self._build_hook_args(hook, name, func, args)
+                hook_args = self._build_hook_args(hook, name, next_func, args)
 
                 if iscoroutinefunction(hook):
                     return await hook(**hook_args)

agno/utils/log.py

@@ -7,6 +7,7 @@ from rich.text import Text
 
 LOGGER_NAME = "agno"
 TEAM_LOGGER_NAME = f"{LOGGER_NAME}-team"
+WORKFLOW_LOGGER_NAME = f"{LOGGER_NAME}-workflow"
 
 # Define custom styles for different log sources
 LOG_STYLES = {
@@ -18,6 +19,10 @@ LOG_STYLES = {
         "debug": "magenta",
         "info": "steel_blue1",
     },
+    "workflow": {
+        "debug": "sandy_brown",
+        "info": "orange3",
+    },
 }
 
 
@@ -92,6 +97,7 @@ def build_logger(logger_name: str, source_type: Optional[str] = None) -> Any:
 
 agent_logger: AgnoLogger = build_logger(LOGGER_NAME, source_type="agent")
 team_logger: AgnoLogger = build_logger(TEAM_LOGGER_NAME, source_type="team")
+workflow_logger: AgnoLogger = build_logger(WORKFLOW_LOGGER_NAME, source_type="workflow")
 
 # Set the default logger to the agent logger
 logger: AgnoLogger = agent_logger
@@ -146,6 +152,12 @@ def use_agent_logger():
     logger = agent_logger
 
 
+def use_workflow_logger():
+    """Switch the default logger to use workflow_logger"""
+    global logger
+    logger = workflow_logger
+
+
 def log_debug(msg, center: bool = False, symbol: str = "*", log_level: Literal[1, 2] = 1, *args, **kwargs):
     global logger
     global debug_on

agno/utils/message.py

@@ -1,13 +1,17 @@
 from typing import Dict, List, Union
 
+from pydantic import BaseModel
+
 from agno.models.message import Message
 
 
-def get_text_from_message(message: Union[List, Dict, str, Message]) -> str:
+def get_text_from_message(message: Union[List, Dict, str, Message, BaseModel]) -> str:
     """Return the user texts from the message"""
 
     if isinstance(message, str):
         return message
+    if isinstance(message, BaseModel):
+        return message.model_dump_json(indent=2, exclude_none=True)
     if isinstance(message, list):
         text_messages = []
         if len(message) == 0: