agno 2.0.1__py3-none-any.whl → 2.3.0__py3-none-any.whl

agno/run/workflow.py

@@ -6,10 +6,15 @@ from typing import TYPE_CHECKING, Any, Dict, List, Optional, Union
 from pydantic import BaseModel
 
 from agno.media import Audio, Image, Video
-from agno.run.agent import RunOutput
-from agno.run.base import RunStatus
-from agno.run.team import TeamRunOutput
-from agno.utils.log import log_error
+from agno.run.agent import RunEvent, RunOutput, run_output_event_from_dict
+from agno.run.base import BaseRunOutputEvent, RunStatus
+from agno.run.team import TeamRunEvent, TeamRunOutput, team_run_output_event_from_dict
+from agno.utils.media import (
+    reconstruct_audio_list,
+    reconstruct_images,
+    reconstruct_response_audio,
+    reconstruct_videos,
+)
 
 if TYPE_CHECKING:
     from agno.workflow.types import StepOutput, WorkflowMetrics
@@ -26,6 +31,9 @@ class WorkflowRunEvent(str, Enum):
     workflow_cancelled = "WorkflowCancelled"
     workflow_error = "WorkflowError"
 
+    workflow_agent_started = "WorkflowAgentStarted"
+    workflow_agent_completed = "WorkflowAgentCompleted"
+
     step_started = "StepStarted"
     step_completed = "StepCompleted"
     step_error = "StepError"
@@ -53,7 +61,7 @@ class WorkflowRunEvent(str, Enum):
 
 
 @dataclass
-class BaseWorkflowRunOutputEvent:
+class BaseWorkflowRunOutputEvent(BaseRunOutputEvent):
     """Base class for all workflow run response events"""
 
     created_at: int = field(default_factory=lambda: int(time()))
@@ -75,33 +83,26 @@ class BaseWorkflowRunOutputEvent:
 
         # Handle StepOutput fields that contain Message objects
         if hasattr(self, "step_results") and self.step_results is not None:
-            _dict["step_results"] = [step.to_dict() for step in self.step_results]
+            _dict["step_results"] = [step.to_dict() if hasattr(step, "to_dict") else step for step in self.step_results]
 
         if hasattr(self, "step_response") and self.step_response is not None:
-            _dict["step_response"] = self.step_response.to_dict()
+            _dict["step_response"] = (
+                self.step_response.to_dict() if hasattr(self.step_response, "to_dict") else self.step_response
+            )
 
         if hasattr(self, "iteration_results") and self.iteration_results is not None:
-            _dict["iteration_results"] = [step.to_dict() for step in self.iteration_results]
+            _dict["iteration_results"] = [
+                step.to_dict() if hasattr(step, "to_dict") else step for step in self.iteration_results
+            ]
 
         if hasattr(self, "all_results") and self.all_results is not None:
-            _dict["all_results"] = [[step.to_dict() for step in iteration] for iteration in self.all_results]
-
-        if hasattr(self, "step_results") and self.step_results is not None:
-            _dict["step_results"] = [step.to_dict() for step in self.step_results]
+            _dict["all_results"] = [
+                [step.to_dict() if hasattr(step, "to_dict") else step for step in iteration]
+                for iteration in self.all_results
+            ]
 
         return _dict
 
-    def to_json(self) -> str:
-        import json
-
-        try:
-            _dict = self.to_dict()
-        except Exception:
-            log_error("Failed to convert response to json", exc_info=True)
-            raise
-
-        return json.dumps(_dict, indent=2)
-
     @property
     def is_cancelled(self):
         return False
@@ -128,6 +129,21 @@ class WorkflowStartedEvent(BaseWorkflowRunOutputEvent):
     event: str = WorkflowRunEvent.workflow_started.value
 
 
+@dataclass
+class WorkflowAgentStartedEvent(BaseWorkflowRunOutputEvent):
+    """Event sent when workflow agent starts (before deciding to run workflow or answer directly)"""
+
+    event: str = WorkflowRunEvent.workflow_agent_started.value
+
+
+@dataclass
+class WorkflowAgentCompletedEvent(BaseWorkflowRunOutputEvent):
+    """Event sent when workflow agent completes (after running workflow or answering directly)"""
+
+    event: str = WorkflowRunEvent.workflow_agent_completed.value
+    content: Optional[Any] = None
+
+
 @dataclass
 class WorkflowCompletedEvent(BaseWorkflowRunOutputEvent):
     """Event sent when workflow execution completes"""
@@ -148,6 +164,11 @@ class WorkflowErrorEvent(BaseWorkflowRunOutputEvent):
     event: str = WorkflowRunEvent.workflow_error.value
     error: Optional[str] = None
 
+    # From exceptions
+    error_type: Optional[str] = None
+    error_id: Optional[str] = None
+    additional_data: Optional[Dict[str, Any]] = None
+
 
 @dataclass
 class WorkflowCancelledEvent(BaseWorkflowRunOutputEvent):
@@ -391,10 +412,17 @@ class CustomEvent(BaseWorkflowRunOutputEvent):
 
     event: str = WorkflowRunEvent.custom_event.value
 
+    def __init__(self, **kwargs):
+        # Store arbitrary attributes directly on the instance
+        for key, value in kwargs.items():
+            setattr(self, key, value)
+
 
 # Union type for all workflow run response events
 WorkflowRunOutputEvent = Union[
     WorkflowStartedEvent,
+    WorkflowAgentStartedEvent,
+    WorkflowAgentCompletedEvent,
     WorkflowCompletedEvent,
     WorkflowErrorEvent,
     WorkflowCancelledEvent,
@@ -417,11 +445,52 @@ WorkflowRunOutputEvent = Union[
     CustomEvent,
 ]
 
+# Map event string to dataclass for workflow events
+WORKFLOW_RUN_EVENT_TYPE_REGISTRY = {
+    WorkflowRunEvent.workflow_started.value: WorkflowStartedEvent,
+    WorkflowRunEvent.workflow_agent_started.value: WorkflowAgentStartedEvent,
+    WorkflowRunEvent.workflow_agent_completed.value: WorkflowAgentCompletedEvent,
+    WorkflowRunEvent.workflow_completed.value: WorkflowCompletedEvent,
+    WorkflowRunEvent.workflow_cancelled.value: WorkflowCancelledEvent,
+    WorkflowRunEvent.workflow_error.value: WorkflowErrorEvent,
+    WorkflowRunEvent.step_started.value: StepStartedEvent,
+    WorkflowRunEvent.step_completed.value: StepCompletedEvent,
+    WorkflowRunEvent.step_error.value: StepErrorEvent,
+    WorkflowRunEvent.loop_execution_started.value: LoopExecutionStartedEvent,
+    WorkflowRunEvent.loop_iteration_started.value: LoopIterationStartedEvent,
+    WorkflowRunEvent.loop_iteration_completed.value: LoopIterationCompletedEvent,
+    WorkflowRunEvent.loop_execution_completed.value: LoopExecutionCompletedEvent,
+    WorkflowRunEvent.parallel_execution_started.value: ParallelExecutionStartedEvent,
+    WorkflowRunEvent.parallel_execution_completed.value: ParallelExecutionCompletedEvent,
+    WorkflowRunEvent.condition_execution_started.value: ConditionExecutionStartedEvent,
+    WorkflowRunEvent.condition_execution_completed.value: ConditionExecutionCompletedEvent,
+    WorkflowRunEvent.router_execution_started.value: RouterExecutionStartedEvent,
+    WorkflowRunEvent.router_execution_completed.value: RouterExecutionCompletedEvent,
+    WorkflowRunEvent.steps_execution_started.value: StepsExecutionStartedEvent,
+    WorkflowRunEvent.steps_execution_completed.value: StepsExecutionCompletedEvent,
+    WorkflowRunEvent.step_output.value: StepOutputEvent,
+    WorkflowRunEvent.custom_event.value: CustomEvent,
+}
+
+
+def workflow_run_output_event_from_dict(data: dict) -> BaseWorkflowRunOutputEvent:
+    event_type = data.get("event", "")
+    if event_type in {e.value for e in RunEvent}:
+        return run_output_event_from_dict(data)  # type: ignore
+    elif event_type in {e.value for e in TeamRunEvent}:
+        return team_run_output_event_from_dict(data)  # type: ignore
+    else:
+        event_class = WORKFLOW_RUN_EVENT_TYPE_REGISTRY.get(event_type)
+    if not event_class:
+        raise ValueError(f"Unknown workflow event type: {event_type}")
+    return event_class.from_dict(data)  # type: ignore
+
 
 @dataclass
 class WorkflowRunOutput:
     """Response returned by Workflow.run() functions - kept for backwards compatibility"""
 
+    input: Optional[Union[str, Dict[str, Any], List[Any], BaseModel]] = None
     content: Optional[Union[str, Dict[str, Any], List[Any], BaseModel, Any]] = None
     content_type: str = "str"
 
@@ -444,6 +513,10 @@ class WorkflowRunOutput:
     # Store agent/team responses separately with parent_run_id references
     step_executor_runs: Optional[List[Union[RunOutput, TeamRunOutput]]] = None
 
+    # Workflow agent run - stores the full agent RunOutput when workflow agent is used
+    # The agent's parent_run_id will point to this workflow run's run_id to establish the relationship
+    workflow_agent_run: Optional[RunOutput] = None
+
     # Store events from workflow execution
     events: Optional[List[WorkflowRunOutputEvent]] = None
 
@@ -475,6 +548,7 @@ class WorkflowRunOutput:
                 "step_executor_runs",
                 "events",
                 "metrics",
+                "workflow_agent_run",
             ]
         }
 
@@ -510,9 +584,18 @@ class WorkflowRunOutput:
         if self.step_executor_runs:
             _dict["step_executor_runs"] = [run.to_dict() for run in self.step_executor_runs]
 
+        if self.workflow_agent_run is not None:
+            _dict["workflow_agent_run"] = self.workflow_agent_run.to_dict()
+
         if self.metrics is not None:
             _dict["metrics"] = self.metrics.to_dict()
 
+        if self.input is not None:
+            if isinstance(self.input, BaseModel):
+                _dict["input"] = self.input.model_dump(exclude_none=True)
+            else:
+                _dict["input"] = self.input
+
         if self.content and isinstance(self.content, BaseModel):
             _dict["content"] = self.content.model_dump(exclude_none=True)
 
@@ -551,24 +634,51 @@ class WorkflowRunOutput:
                 else:
                     step_executor_runs.append(RunOutput.from_dict(run_data))
 
+        workflow_agent_run_data = data.pop("workflow_agent_run", None)
+        workflow_agent_run = None
+        if workflow_agent_run_data:
+            if isinstance(workflow_agent_run_data, dict):
+                workflow_agent_run = RunOutput.from_dict(workflow_agent_run_data)
+            elif isinstance(workflow_agent_run_data, RunOutput):
+                workflow_agent_run = workflow_agent_run_data
+
         metadata = data.pop("metadata", None)
 
-        images = data.pop("images", [])
-        images = [Image.model_validate(image) for image in images] if images else None
+        images = reconstruct_images(data.pop("images", []))
+        videos = reconstruct_videos(data.pop("videos", []))
+        audio = reconstruct_audio_list(data.pop("audio", []))
+        response_audio = reconstruct_response_audio(data.pop("response_audio", None))
+
+        events_data = data.pop("events", [])
+        final_events = []
+        for event in events_data or []:
+            if "agent_id" in event:
+                # Agent event from agent step
+                from agno.run.agent import run_output_event_from_dict
+
+                event = run_output_event_from_dict(event)
+            elif "team_id" in event:
+                # Team event from team step
+                from agno.run.team import team_run_output_event_from_dict
 
-        videos = data.pop("videos", [])
-        videos = [Video.model_validate(video) for video in videos] if videos else None
+                event = team_run_output_event_from_dict(event)
+            else:
+                # Pure workflow event
+                event = workflow_run_output_event_from_dict(event)
+            final_events.append(event)
+        events = final_events
 
-        audio = data.pop("audio", [])
-        audio = [Audio.model_validate(audio) for audio in audio] if audio else None
+        input_data = data.pop("input", None)
 
-        response_audio = data.pop("response_audio", None)
-        response_audio = Audio.model_validate(response_audio) if response_audio else None
+        # Filter data to only include fields that are actually defined in the WorkflowRunOutput dataclass
+        from dataclasses import fields
 
-        events = data.pop("events", [])
+        supported_fields = {f.name for f in fields(cls)}
+        filtered_data = {k: v for k, v in data.items() if k in supported_fields}
 
         return cls(
             step_results=parsed_step_results,
+            workflow_agent_run=workflow_agent_run,
             metadata=metadata,
             images=images,
             videos=videos,
@@ -577,7 +687,8 @@ class WorkflowRunOutput:
             events=events,
             metrics=workflow_metrics,
             step_executor_runs=step_executor_runs,
-            **data,
+            input=input_data,
+            **filtered_data,
         )
 
     def get_content_as_string(self, **kwargs) -> str:

agno/session/agent.py

@@ -1,11 +1,12 @@
 from __future__ import annotations
 
 from dataclasses import asdict, dataclass
-from typing import Any, Dict, List, Mapping, Optional
+from typing import Any, Dict, List, Mapping, Optional, Union
 
 from agno.models.message import Message
 from agno.run.agent import RunOutput
 from agno.run.base import RunStatus
+from agno.run.team import TeamRunOutput
 from agno.session.summary import SessionSummary
 from agno.utils.log import log_debug, log_warning
 
@@ -33,7 +34,7 @@ class AgentSession:
     # Agent Data: agent_id, name and model
     agent_data: Optional[Dict[str, Any]] = None
     # List of all runs in the session
-    runs: Optional[List[RunOutput]] = None
+    runs: Optional[List[Union[RunOutput, TeamRunOutput]]] = None
     # Summary of the session
     summary: Optional["SessionSummary"] = None
 
@@ -57,8 +58,13 @@ class AgentSession:
             return None
 
         runs = data.get("runs")
+        serialized_runs: List[Union[RunOutput, TeamRunOutput]] = []
         if runs is not None and isinstance(runs[0], dict):
-            runs = [RunOutput.from_dict(run) for run in runs]
+            for run in runs:
+                if "agent_id" in run:
+                    serialized_runs.append(RunOutput.from_dict(run))
+                elif "team_id" in run:
+                    serialized_runs.append(TeamRunOutput.from_dict(run))
 
         summary = data.get("summary")
         if summary is not None and isinstance(summary, dict):
@@ -77,7 +83,7 @@ class AgentSession:
             metadata=metadata,
             created_at=data.get("created_at"),
             updated_at=data.get("updated_at"),
-            runs=runs,
+            runs=serialized_runs,
             summary=summary,
         )
 
@@ -100,74 +106,136 @@ class AgentSession:
 
         log_debug("Added RunOutput to Agent Session")
 
-    def get_run(self, run_id: str) -> Optional[RunOutput]:
+    def get_run(self, run_id: str) -> Optional[Union[RunOutput, TeamRunOutput]]:
         for run in self.runs or []:
             if run.run_id == run_id:
                 return run
         return None
 
-    def get_messages_from_last_n_runs(
+    def get_messages(
         self,
         agent_id: Optional[str] = None,
         team_id: Optional[str] = None,
-        last_n: Optional[int] = None,
-        skip_role: Optional[str] = None,
-        skip_status: Optional[List[RunStatus]] = None,
+        last_n_runs: Optional[int] = None,
+        limit: Optional[int] = None,
+        skip_roles: Optional[List[str]] = None,
+        skip_statuses: Optional[List[RunStatus]] = None,
         skip_history_messages: bool = True,
     ) -> List[Message]:
-        """Returns the messages from the last_n runs, excluding previously tagged history messages.
+        """Returns the messages belonging to the session that fit the given criteria.
+
         Args:
             agent_id: The id of the agent to get the messages from.
             team_id: The id of the team to get the messages from.
-            last_n: The number of runs to return from the end of the conversation. Defaults to all runs.
-            skip_role: Skip messages with this role.
-            skip_status: Skip messages with this status.
+            last_n_runs: The number of runs to return messages from, counting from the latest. Defaults to all runs.
+            last_n_messages: The number of messages to return, counting from the latest. Defaults to all messages.
+            skip_roles: Skip messages with these roles.
+            skip_statuses: Skip messages with these statuses.
             skip_history_messages: Skip messages that were tagged as history in previous runs.
+
         Returns:
-            A list of Messages from the specified runs, excluding history messages.
+            A list of Messages belonging to the session.
         """
+
+        def _should_skip_message(
+            message: Message, skip_roles: Optional[List[str]] = None, skip_history_messages: bool = True
+        ) -> bool:
+            """Logic to determine if a message should be skipped"""
+            # Skip messages that were tagged as history in previous runs
+            if hasattr(message, "from_history") and message.from_history and skip_history_messages:
+                return True
+
+            # Skip messages with specified role
+            if skip_roles and message.role in skip_roles:
+                return True
+
+            return False
+
         if not self.runs:
             return []
 
-        if skip_status is None:
-            skip_status = [RunStatus.paused, RunStatus.cancelled, RunStatus.error]
+        if skip_statuses is None:
+            skip_statuses = [RunStatus.paused, RunStatus.cancelled, RunStatus.error]
+
+        runs = self.runs
 
-        session_runs = self.runs
         # Filter by agent_id and team_id
         if agent_id:
-            session_runs = [run for run in session_runs if hasattr(run, "agent_id") and run.agent_id == agent_id]  # type: ignore
+            runs = [run for run in runs if hasattr(run, "agent_id") and run.agent_id == agent_id]  # type: ignore
         if team_id:
-            session_runs = [run for run in session_runs if hasattr(run, "team_id") and run.team_id == team_id]  # type: ignore
+            runs = [run for run in runs if hasattr(run, "team_id") and run.team_id == team_id]  # type: ignore
+
+        # Skip any messages that might be part of members of teams (for session re-use)
+        runs = [run for run in runs if run.parent_run_id is None]  # type: ignore
 
         # Filter by status
-        session_runs = [run for run in session_runs if hasattr(run, "status") and run.status not in skip_status]  # type: ignore
+        runs = [run for run in runs if hasattr(run, "status") and run.status not in skip_statuses]  # type: ignore
 
-        # Filter by last_n
-        runs_to_process = session_runs[-last_n:] if last_n is not None else session_runs
         messages_from_history = []
         system_message = None
-        for run_response in runs_to_process:
-            if not (run_response and run_response.messages):
-                continue
 
-            for message in run_response.messages or []:
-                # Skip messages with specified role
-                if skip_role and message.role == skip_role:
+        # Limit the number of messages returned if limit is set
+        if limit is not None:
+            for run_response in runs:
+                if not run_response or not run_response.messages:
                     continue
-                # Skip messages that were tagged as history in previous runs
-                if hasattr(message, "from_history") and message.from_history and skip_history_messages:
+
+                for message in run_response.messages or []:
+                    if _should_skip_message(message, skip_roles, skip_history_messages):
+                        continue
+
+                    if message.role == "system":
+                        # Only add the system message once
+                        if system_message is None:
+                            system_message = message
+                    else:
+                        messages_from_history.append(message)
+
+            if system_message:
+                messages_from_history = [system_message] + messages_from_history[
+                    -(limit - 1) :
+                ]  # Grab one less message then add the system message
+            else:
+                messages_from_history = messages_from_history[-limit:]
+
+            # Remove tool result messages that don't have an associated assistant message with tool calls
+            while len(messages_from_history) > 0 and messages_from_history[0].role == "tool":
+                messages_from_history.pop(0)
+
+        # If limit is not set, return all messages
+        else:
+            runs_to_process = runs[-last_n_runs:] if last_n_runs is not None else runs
+            for run_response in runs_to_process:
+                if not run_response or not run_response.messages:
                     continue
-                if message.role == "system":
-                    # Only add the system message once
-                    if system_message is None:
-                        system_message = message
-                        messages_from_history.append(system_message)
-                else:
-                    messages_from_history.append(message)
+
+                for message in run_response.messages or []:
+                    if _should_skip_message(message, skip_roles, skip_history_messages):
+                        continue
+
+                    if message.role == "system":
+                        # Only add the system message once
+                        if system_message is None:
+                            system_message = message
+                            messages_from_history.append(system_message)
+                    else:
+                        messages_from_history.append(message)
 
         log_debug(f"Getting messages from previous runs: {len(messages_from_history)}")
         return messages_from_history
 
+    def get_chat_history(self, last_n_runs: Optional[int] = None) -> List[Message]:
+        """Return the chat history (user and assistant messages) for the session.
+        Use get_messages() for more filtering options.
+
+        Args:
+            last_n_runs: Number of recent runs to include. If None, all runs will be considered.
+
+        Returns:
+            A list of user and assistant Messages belonging to the session.
+        """
+        return self.get_messages(skip_roles=["system", "tool"], last_n_runs=last_n_runs)
+
     def get_tool_calls(self, num_calls: Optional[int] = None) -> List[Dict[str, Any]]:
         """Returns a list of tool calls from the messages"""
 
@@ -184,61 +252,9 @@ class AgentSession:
                                     return tool_calls
         return tool_calls
 
-    def get_messages_for_session(
-        self,
-        user_role: str = "user",
-        assistant_role: Optional[List[str]] = None,
-        skip_history_messages: bool = True,
-    ) -> List[Message]:
-        """Returns a list of messages for the session that iterate through user message and assistant response."""
-
-        if assistant_role is None:
-            # TODO: Check if we still need CHATBOT as a role
-            assistant_role = ["assistant", "model", "CHATBOT"]
-
-        final_messages: List[Message] = []
-        session_runs = self.runs
-        if not session_runs:
-            return []
-
-        for run_response in session_runs:
-            if run_response and run_response.messages:
-                user_message_from_run = None
-                assistant_message_from_run = None
-
-                # Start from the beginning to look for the user message
-                for message in run_response.messages or []:
-                    if hasattr(message, "from_history") and message.from_history and skip_history_messages:
-                        continue
-                    if message.role == user_role:
-                        user_message_from_run = message
-                        break
-
-                # Start from the end to look for the assistant response
-                for message in run_response.messages[::-1]:
-                    if hasattr(message, "from_history") and message.from_history and skip_history_messages:
-                        continue
-                    if message.role in assistant_role:
-                        assistant_message_from_run = message
-                        break
-
-                if user_message_from_run and assistant_message_from_run:
-                    final_messages.append(user_message_from_run)
-                    final_messages.append(assistant_message_from_run)
-        return final_messages
-
     def get_session_summary(self) -> Optional[SessionSummary]:
         """Get the session summary for the session"""
 
         if self.summary is None:
             return None
         return self.summary
-
-    # Chat History functions
-    def get_chat_history(self) -> List[Message]:
-        """Get the chat history for the session"""
-
-        messages = []
-        for run in self.runs or []:
-            messages.extend([msg for msg in run.messages or [] if not msg.from_history])
-        return messages