agno 1.8.1__py3-none-any.whl → 2.0.0a1__py3-none-any.whl

agno/workflow/{v2/step.py → step.py}

@@ -1,22 +1,26 @@
 import inspect
+from copy import copy
 from dataclasses import dataclass
 from typing import Any, AsyncIterator, Awaitable, Callable, Dict, Iterator, List, Optional, Union
+from uuid import uuid4
 
 from pydantic import BaseModel
 
 from agno.agent import Agent
 from agno.media import Audio, AudioArtifact, Image, ImageArtifact, Video, VideoArtifact
-from agno.run.response import RunResponse
-from agno.run.team import TeamRunResponse
-from agno.run.v2.workflow import (
+from agno.models.metrics import Metrics
+from agno.run.agent import RunOutput
+from agno.run.team import TeamRunOutput
+from agno.run.workflow import (
     StepCompletedEvent,
     StepStartedEvent,
-    WorkflowRunResponse,
-    WorkflowRunResponseEvent,
+    WorkflowRunOutput,
+    WorkflowRunOutputEvent,
 )
 from agno.team import Team
 from agno.utils.log import log_debug, logger, use_agent_logger, use_team_logger, use_workflow_logger
-from agno.workflow.v2.types import StepInput, StepOutput
+from agno.utils.merge_dict import merge_dictionaries
+from agno.workflow.types import StepInput, StepOutput, StepType
 
 StepExecutor = Callable[
     [StepInput],
@@ -89,6 +93,10 @@ class Step:
         self.timeout_seconds = timeout_seconds
         self.skip_on_failure = skip_on_failure
         self.strict_input_validation = strict_input_validation
+        self.step_id = step_id
+
+        if step_id is None:
+            self.step_id = str(uuid4())
 
         # Set the active executor
         self._set_active_executor()
@@ -150,19 +158,20 @@ class Step:
         else:
             raise ValueError("No executor configured")
 
-    def _extract_metrics_from_response(self, response: Union[RunResponse, TeamRunResponse]) -> Optional[Dict[str, Any]]:
+    def _extract_metrics_from_response(self, response: Union[RunOutput, TeamRunOutput]) -> Optional[Metrics]:
         """Extract metrics from agent or team response"""
         if hasattr(response, "metrics") and response.metrics:
-            return {
-                "step_name": self.name,
-                "executor_type": self._executor_type,
-                "executor_name": self.executor_name,
-                "metrics": response.metrics,
-            }
+            return response.metrics
         return None
 
     def execute(
-        self, step_input: StepInput, session_id: Optional[str] = None, user_id: Optional[str] = None
+        self,
+        step_input: StepInput,
+        session_id: Optional[str] = None,
+        user_id: Optional[str] = None,
+        workflow_run_response: Optional["WorkflowRunOutput"] = None,
+        session_state: Optional[Dict[str, Any]] = None,
+        store_executor_outputs: bool = True,
     ) -> StepOutput:
         """Execute the step with StepInput, returning final StepOutput (non-streaming)"""
         log_debug(f"Executing step: {self.name}")
@@ -173,7 +182,7 @@ class Step:
         # Execute with retries
         for attempt in range(self.max_retries + 1):
             try:
-                response: Union[RunResponse, TeamRunResponse, StepOutput]
+                response: Union[RunOutput, TeamRunOutput, StepOutput]
                 if self._executor_type == "function":
                     if inspect.iscoroutinefunction(self.active_executor) or inspect.isasyncgenfunction(
                         self.active_executor
@@ -215,7 +224,7 @@ class Step:
                 else:
                     # For agents and teams, prepare message with context
                     message = self._prepare_message(
-                        step_input.message,
+                        step_input.input,
                         step_input.previous_step_outputs,
                     )
 
@@ -234,16 +243,30 @@ class Step:
                             self._convert_video_artifacts_to_videos(step_input.videos) if step_input.videos else None
                         )
                         audios = self._convert_audio_artifacts_to_audio(step_input.audio) if step_input.audio else None
-                        response = self.active_executor.run(  # type: ignore[misc]
-                            message=message,
+
+                        kwargs: Dict[str, Any] = {}
+                        if isinstance(self.active_executor, Team):
+                            kwargs["store_member_responses"] = True
+
+                        session_state_copy = copy(session_state)
+                        response = self.active_executor.run(  # type: ignore
+                            input=message,  # type: ignore
                             images=images,
                             videos=videos,
                             audio=audios,
                             files=step_input.files,
                             session_id=session_id,
                             user_id=user_id,
+                            session_state=session_state_copy,  # Send a copy to the executor
+                            **kwargs,
                         )
 
+                        # Update workflow session state
+                        merge_dictionaries(session_state, session_state_copy)  # type: ignore
+
+                        if store_executor_outputs and workflow_run_response is not None:
+                            self._store_executor_response(workflow_run_response, response)  # type: ignore
+
                         # Switch back to workflow logger after execution
                         use_workflow_logger()
                     else:
@@ -274,9 +297,12 @@ class Step:
         session_id: Optional[str] = None,
         user_id: Optional[str] = None,
         stream_intermediate_steps: bool = False,
-        workflow_run_response: Optional["WorkflowRunResponse"] = None,
+        workflow_run_response: Optional["WorkflowRunOutput"] = None,
+        session_state: Optional[Dict[str, Any]] = None,
         step_index: Optional[Union[int, tuple]] = None,
-    ) -> Iterator[Union[WorkflowRunResponseEvent, StepOutput]]:
+        store_executor_outputs: bool = True,
+        parent_step_id: Optional[str] = None,
+    ) -> Iterator[Union[WorkflowRunOutputEvent, StepOutput]]:
         """Execute the step with event-driven streaming support"""
 
         if step_input.previous_step_outputs:
@@ -291,6 +317,8 @@ class Step:
                 session_id=workflow_run_response.session_id or "",
                 step_name=self.name,
                 step_index=step_index,
+                step_id=self.step_id,
+                parent_step_id=parent_step_id,
             )
 
         # Execute with retries and streaming
@@ -341,7 +369,7 @@ class Step:
                 else:
                     # For agents and teams, prepare message with context
                     message = self._prepare_message(
-                        step_input.message,
+                        step_input.input,
                         step_input.previous_step_outputs,
                     )
 
@@ -359,21 +387,49 @@ class Step:
                             self._convert_video_artifacts_to_videos(step_input.videos) if step_input.videos else None
                         )
                         audios = self._convert_audio_artifacts_to_audio(step_input.audio) if step_input.audio else None
+
+                        kwargs: Dict[str, Any] = {}
+                        if isinstance(self.active_executor, Team):
+                            kwargs["store_member_responses"] = True
+
+                        session_state_copy = copy(session_state)
                         response_stream = self.active_executor.run(  # type: ignore[call-overload, misc]
-                            message=message,
+                            input=message,
                             images=images,
                             videos=videos,
                             audio=audios,
                             files=step_input.files,
                             session_id=session_id,
                             user_id=user_id,
+                            session_state=session_state_copy,  # Send a copy to the executor
                             stream=True,
                             stream_intermediate_steps=stream_intermediate_steps,
+                            # Pass workflow context directly via kwargs
+                            workflow_context={
+                                "workflow_id": workflow_run_response.workflow_id if workflow_run_response else None,
+                                "workflow_run_id": workflow_run_response.run_id if workflow_run_response else None,
+                                "step_id": self.step_id,
+                                "step_name": self.name,
+                                "step_index": step_index,
+                            },
+                            yield_run_response=True,
+                            **kwargs,
                         )
 
+                        active_executor_run_response = None
                         for event in response_stream:
+                            if isinstance(event, RunOutput) or isinstance(event, TeamRunOutput):
+                                active_executor_run_response = event
+                                break
                             yield event  # type: ignore[misc]
-                        final_response = self._process_step_output(self.active_executor.run_response)  # type: ignore
+
+                        # Update workflow session state
+                        merge_dictionaries(session_state, session_state_copy)  # type: ignore
+
+                        if store_executor_outputs and workflow_run_response is not None:
+                            self._store_executor_response(workflow_run_response, active_executor_run_response)  # type: ignore
+
+                        final_response = self._process_step_output(active_executor_run_response)  # type: ignore
 
                     else:
                         raise ValueError(f"Unsupported executor type: {self._executor_type}")
@@ -400,6 +456,7 @@ class Step:
                         step_index=step_index,
                         content=final_response.content,
                         step_response=final_response,
+                        parent_step_id=parent_step_id,
                     )
 
                 return
@@ -422,7 +479,13 @@ class Step:
         return
 
     async def aexecute(
-        self, step_input: StepInput, session_id: Optional[str] = None, user_id: Optional[str] = None
+        self,
+        step_input: StepInput,
+        session_id: Optional[str] = None,
+        user_id: Optional[str] = None,
+        workflow_run_response: Optional["WorkflowRunOutput"] = None,
+        session_state: Optional[Dict[str, Any]] = None,
+        store_executor_outputs: bool = True,
     ) -> StepOutput:
         """Execute the step with StepInput, returning final StepOutput (non-streaming)"""
         logger.info(f"Executing async step (non-streaming): {self.name}")
@@ -492,7 +555,7 @@ class Step:
                 else:
                     # For agents and teams, prepare message with context
                     message = self._prepare_message(
-                        step_input.message,
+                        step_input.input,
                         step_input.previous_step_outputs,
                     )
 
@@ -511,16 +574,30 @@ class Step:
                             self._convert_video_artifacts_to_videos(step_input.videos) if step_input.videos else None
                         )
                         audios = self._convert_audio_artifacts_to_audio(step_input.audio) if step_input.audio else None
+
+                        kwargs: Dict[str, Any] = {}
+                        if isinstance(self.active_executor, Team):
+                            kwargs["store_member_responses"] = True
+
+                        session_state_copy = copy(session_state)
                         response = await self.active_executor.arun(  # type: ignore
-                            message=message,
+                            input=message,  # type: ignore
                             images=images,
                             videos=videos,
                             audio=audios,
                             files=step_input.files,
                             session_id=session_id,
                             user_id=user_id,
+                            session_state=session_state_copy,
+                            **kwargs,
                         )
 
+                        # Update workflow session state
+                        merge_dictionaries(session_state, session_state_copy)  # type: ignore
+
+                        if store_executor_outputs and workflow_run_response is not None:
+                            self._store_executor_response(workflow_run_response, response)  # type: ignore
+
                         # Switch back to workflow logger after execution
                         use_workflow_logger()
                     else:
@@ -551,9 +628,12 @@ class Step:
         session_id: Optional[str] = None,
         user_id: Optional[str] = None,
         stream_intermediate_steps: bool = False,
-        workflow_run_response: Optional["WorkflowRunResponse"] = None,
+        workflow_run_response: Optional["WorkflowRunOutput"] = None,
+        session_state: Optional[Dict[str, Any]] = None,
         step_index: Optional[Union[int, tuple]] = None,
-    ) -> AsyncIterator[Union[WorkflowRunResponseEvent, StepOutput]]:
+        store_executor_outputs: bool = True,
+        parent_step_id: Optional[str] = None,
+    ) -> AsyncIterator[Union[WorkflowRunOutputEvent, StepOutput]]:
         """Execute the step with event-driven streaming support"""
 
         if step_input.previous_step_outputs:
@@ -568,6 +648,8 @@ class Step:
                 session_id=workflow_run_response.session_id or "",
                 step_name=self.name,
                 step_index=step_index,
+                step_id=self.step_id,
+                parent_step_id=parent_step_id,
             )
 
         # Execute with retries and streaming
@@ -636,7 +718,7 @@ class Step:
                 else:
                     # For agents and teams, prepare message with context
                     message = self._prepare_message(
-                        step_input.message,
+                        step_input.input,
                         step_input.previous_step_outputs,
                     )
 
@@ -654,22 +736,50 @@ class Step:
                             self._convert_video_artifacts_to_videos(step_input.videos) if step_input.videos else None
                         )
                         audios = self._convert_audio_artifacts_to_audio(step_input.audio) if step_input.audio else None
-                        response_stream = await self.active_executor.arun(  # type: ignore
-                            message=message,
+
+                        kwargs: Dict[str, Any] = {}
+                        if isinstance(self.active_executor, Team):
+                            kwargs["store_member_responses"] = True
+
+                        session_state_copy = copy(session_state)
+                        response_stream = self.active_executor.arun(  # type: ignore
+                            input=message,
                             images=images,
                             videos=videos,
                             audio=audios,
                             files=step_input.files,
                             session_id=session_id,
                             user_id=user_id,
+                            session_state=session_state_copy,
                             stream=True,
                             stream_intermediate_steps=stream_intermediate_steps,
+                            # Pass workflow context directly via kwargs
+                            workflow_context={
+                                "workflow_id": workflow_run_response.workflow_id if workflow_run_response else None,
+                                "workflow_run_id": workflow_run_response.run_id if workflow_run_response else None,
+                                "step_id": self.step_id,
+                                "step_name": self.name,
+                                "step_index": step_index,
+                            },
+                            yield_run_response=True,
+                            **kwargs,
                         )
 
+                        active_executor_run_response = None
                         async for event in response_stream:
                             log_debug(f"Received async event from agent: {type(event).__name__}")
+                            if isinstance(event, RunOutput) or isinstance(event, TeamRunOutput):
+                                active_executor_run_response = event
+                                break
                             yield event  # type: ignore[misc]
-                        final_response = self._process_step_output(self.active_executor.run_response)  # type: ignore
+
+                        # Update workflow session state
+                        merge_dictionaries(session_state, session_state_copy)  # type: ignore
+
+                        if store_executor_outputs and workflow_run_response is not None:
+                            self._store_executor_response(workflow_run_response, active_executor_run_response)  # type: ignore
+
+                        final_response = self._process_step_output(active_executor_run_response)  # type: ignore
                     else:
                         raise ValueError(f"Unsupported executor type: {self._executor_type}")
 
@@ -692,8 +802,10 @@ class Step:
                         session_id=workflow_run_response.session_id or "",
                         step_name=self.name,
                         step_index=step_index,
+                        step_id=self.step_id,
                         content=final_response.content,
                         step_response=final_response,
+                        parent_step_id=parent_step_id,
                     )
                 return
 
@@ -714,6 +826,48 @@ class Step:
 
         return
 
+    def _store_executor_response(
+        self, workflow_run_response: "WorkflowRunOutput", executor_run_response: Union[RunOutput, TeamRunOutput]
+    ) -> None:
+        """Store agent/team responses in step_executor_runs if enabled"""
+        if self._executor_type in ["agent", "team"]:
+            # propogate the workflow run id as parent run id to the executor response
+            executor_run_response.parent_run_id = workflow_run_response.run_id
+            executor_run_response.workflow_step_id = self.step_id
+
+            # Get the raw response from the step's active executor
+            raw_response = executor_run_response
+            if raw_response and isinstance(raw_response, (RunOutput, TeamRunOutput)):
+                if workflow_run_response.step_executor_runs is None:
+                    workflow_run_response.step_executor_runs = []
+
+                raw_response.workflow_step_id = self.step_id
+                # Add the primary executor run
+                workflow_run_response.step_executor_runs.append(raw_response)
+
+                # Add direct member agent runs (in case of a team we force store_member_responses=True here)
+                if isinstance(raw_response, TeamRunOutput) and getattr(
+                    self.active_executor, "store_member_responses", False
+                ):
+                    for mr in raw_response.member_responses or []:
+                        if isinstance(mr, RunOutput):
+                            workflow_run_response.step_executor_runs.append(mr)
+
+    def _get_deepest_content_from_step_output(self, step_output: "StepOutput") -> Optional[str]:
+        """
+        Extract the deepest content from a step output, handling nested structures like Steps, Router, Loop, etc.
+
+        For container steps (Steps, Router, Loop, etc.), this will recursively find the content from the
+        last actual step rather than using the generic container message.
+        """
+        # If this step has nested steps (like Steps, Condition, Router, Loop, etc.)
+        if hasattr(step_output, "steps") and step_output.steps and len(step_output.steps) > 0:
+            # Recursively get content from the last nested step
+            return self._get_deepest_content_from_step_output(step_output.steps[-1])
+
+        # For regular steps, return their content
+        return step_output.content  # type: ignore
+
     def _prepare_message(
         self,
         message: Optional[Union[str, Dict[str, Any], List[Any], BaseModel]],
@@ -723,17 +877,20 @@ class Step:
 
         if previous_step_outputs and self._executor_type in ["agent", "team"]:
             last_output = list(previous_step_outputs.values())[-1] if previous_step_outputs else None
-            if last_output and last_output.content:
-                return last_output.content
+            if last_output:
+                deepest_content = self._get_deepest_content_from_step_output(last_output)
+                if deepest_content:
+                    return deepest_content
 
         # If no previous step outputs, return the original message unchanged
         return message
 
-    def _process_step_output(self, response: Union[RunResponse, TeamRunResponse, StepOutput]) -> StepOutput:
+    def _process_step_output(self, response: Union[RunOutput, TeamRunOutput, StepOutput]) -> StepOutput:
         """Create StepOutput from execution response"""
         if isinstance(response, StepOutput):
             response.step_name = self.name or "unnamed_step"
             response.step_id = self.step_id
+            response.step_type = StepType.STEP
             response.executor_type = self._executor_type
             response.executor_name = self.executor_name
             return response
@@ -749,29 +906,30 @@ class Step:
         return StepOutput(
             step_name=self.name or "unnamed_step",
             step_id=self.step_id,
+            step_type=StepType.STEP,
             executor_type=self._executor_type,
             executor_name=self.executor_name,
             content=response.content,
-            response=response,
+            step_run_id=getattr(response, "run_id", None),
             images=images,
             videos=videos,
             audio=audio,
             metrics=metrics,
         )
 
-    def _convert_function_result_to_response(self, result: Any) -> RunResponse:
-        """Convert function execution result to RunResponse"""
-        if isinstance(result, RunResponse):
+    def _convert_function_result_to_response(self, result: Any) -> RunOutput:
+        """Convert function execution result to RunOutput"""
+        if isinstance(result, RunOutput):
             return result
         elif isinstance(result, str):
-            return RunResponse(content=result)
+            return RunOutput(content=result)
         elif isinstance(result, dict):
             # If it's a dict, try to extract content
             content = result.get("content", str(result))
-            return RunResponse(content=content)
+            return RunOutput(content=content)
         else:
             # Convert any other type to string
-            return RunResponse(content=str(result))
+            return RunOutput(content=str(result))
 
     def _convert_audio_artifacts_to_audio(self, audio_artifacts: List[AudioArtifact]) -> List[Audio]:
         """Convert AudioArtifact objects to Audio objects"""