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

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

@@ -1,18 +1,19 @@
 import inspect
 from dataclasses import dataclass
-from typing import AsyncIterator, Awaitable, Callable, Dict, Iterator, List, Optional, Union
+from typing import Any, AsyncIterator, Awaitable, Callable, Dict, Iterator, List, Optional, Union
+from uuid import uuid4
 
-from agno.run.response import RunResponseEvent
-from agno.run.team import TeamRunResponseEvent
-from agno.run.v2.workflow import (
+from agno.run.agent import RunOutputEvent
+from agno.run.team import TeamRunOutputEvent
+from agno.run.workflow import (
     RouterExecutionCompletedEvent,
     RouterExecutionStartedEvent,
-    WorkflowRunResponse,
-    WorkflowRunResponseEvent,
+    WorkflowRunOutput,
+    WorkflowRunOutputEvent,
 )
 from agno.utils.log import log_debug, logger
-from agno.workflow.v2.step import Step
-from agno.workflow.v2.types import StepInput, StepOutput
+from agno.workflow.step import Step
+from agno.workflow.types import StepInput, StepOutput, StepType
 
 WorkflowSteps = List[
     Union[
@@ -47,11 +48,11 @@ class Router:
         """Prepare the steps for execution - mirrors workflow logic"""
         from agno.agent.agent import Agent
         from agno.team.team import Team
-        from agno.workflow.v2.condition import Condition
-        from agno.workflow.v2.loop import Loop
-        from agno.workflow.v2.parallel import Parallel
-        from agno.workflow.v2.step import Step
-        from agno.workflow.v2.steps import Steps
+        from agno.workflow.condition import Condition
+        from agno.workflow.loop import Loop
+        from agno.workflow.parallel import Parallel
+        from agno.workflow.step import Step
+        from agno.workflow.steps import Steps
 
         prepared_steps: WorkflowSteps = []
         for step in self.choices:
@@ -97,7 +98,7 @@ class Router:
             updated_previous_step_outputs.update(router_step_outputs)
 
         return StepInput(
-            message=step_input.message,
+            input=step_input.input,
             previous_step_content=previous_step_content,
             previous_step_outputs=updated_previous_step_outputs,
             additional_data=step_input.additional_data,
@@ -142,11 +143,19 @@ class Router:
         return []
 
     def execute(
-        self, step_input: StepInput, session_id: Optional[str] = None, user_id: Optional[str] = None
-    ) -> List[StepOutput]:
+        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 router and its selected steps with sequential chaining"""
         log_debug(f"Router Start: {self.name}", center=True, symbol="-")
 
+        router_step_id = str(uuid4())
+
         self._prepare_steps()
 
         # Route to appropriate steps
@@ -154,7 +163,13 @@ class Router:
         log_debug(f"Router {self.name}: Selected {len(steps_to_execute)} steps to execute")
 
         if not steps_to_execute:
-            return []
+            return StepOutput(
+                step_name=self.name,
+                step_id=router_step_id,
+                step_type=StepType.ROUTER,
+                content=f"Router {self.name} completed with 0 results (no steps selected)",
+                success=True,
+            )
 
         all_results: List[StepOutput] = []
         current_step_input = step_input
@@ -162,7 +177,14 @@ class Router:
 
         for i, step in enumerate(steps_to_execute):
             try:
-                step_output = step.execute(current_step_input, session_id=session_id, user_id=user_id)
+                step_output = step.execute(
+                    current_step_input,
+                    session_id=session_id,
+                    user_id=user_id,
+                    workflow_run_response=workflow_run_response,
+                    store_executor_outputs=store_executor_outputs,
+                    session_state=session_state,
+                )
 
                 # Handle both single StepOutput and List[StepOutput]
                 if isinstance(step_output, list):
@@ -200,22 +222,35 @@ class Router:
                 break
 
         log_debug(f"Router End: {self.name} ({len(all_results)} results)", center=True, symbol="-")
-        return all_results
+
+        return StepOutput(
+            step_name=self.name,
+            step_id=router_step_id,
+            step_type=StepType.ROUTER,
+            content=f"Router {self.name} completed with {len(all_results)} results",
+            success=all(result.success for result in all_results) if all_results else True,
+            steps=all_results,
+        )
 
     def execute_stream(
         self,
         step_input: StepInput,
         session_id: Optional[str] = None,
         user_id: Optional[str] = None,
+        session_state: Optional[Dict[str, Any]] = None,
         stream_intermediate_steps: bool = False,
-        workflow_run_response: Optional[WorkflowRunResponse] = None,
+        workflow_run_response: Optional[WorkflowRunOutput] = 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 router with streaming support"""
         log_debug(f"Router Start: {self.name}", center=True, symbol="-")
 
         self._prepare_steps()
 
+        router_step_id = str(uuid4())
+
         # Route to appropriate steps
         steps_to_execute = self._route_steps(step_input)
         log_debug(f"Router {self.name}: Selected {len(steps_to_execute)} steps to execute")
@@ -230,6 +265,8 @@ class Router:
                 step_name=self.name,
                 step_index=step_index,
                 selected_steps=[getattr(step, "name", f"step_{i}") for i, step in enumerate(steps_to_execute)],
+                step_id=router_step_id,
+                parent_step_id=parent_step_id,
             )
 
         if not steps_to_execute:
@@ -245,6 +282,8 @@ class Router:
                     selected_steps=[],
                     executed_steps=0,
                     step_results=[],
+                    step_id=router_step_id,
+                    parent_step_id=parent_step_id,
                 )
             return
 
@@ -263,6 +302,9 @@ class Router:
                     stream_intermediate_steps=stream_intermediate_steps,
                     workflow_run_response=workflow_run_response,
                     step_index=step_index,
+                    store_executor_outputs=store_executor_outputs,
+                    session_state=session_state,
+                    parent_step_id=router_step_id,
                 ):
                     if isinstance(event, StepOutput):
                         step_outputs_for_step.append(event)
@@ -323,17 +365,33 @@ class Router:
                 selected_steps=[getattr(step, "name", f"step_{i}") for i, step in enumerate(steps_to_execute)],
                 executed_steps=len(steps_to_execute),
                 step_results=all_results,
+                step_id=router_step_id,
+                parent_step_id=parent_step_id,
             )
 
-        for result in all_results:
-            yield result
+        yield StepOutput(
+            step_name=self.name,
+            step_id=router_step_id,
+            step_type=StepType.ROUTER,
+            content=f"Router {self.name} completed with {len(all_results)} results",
+            success=all(result.success for result in all_results) if all_results else True,
+            steps=all_results,
+        )
 
     async def aexecute(
-        self, step_input: StepInput, session_id: Optional[str] = None, user_id: Optional[str] = None
-    ) -> List[StepOutput]:
+        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:
         """Async execute the router and its selected steps with sequential chaining"""
         log_debug(f"Router Start: {self.name}", center=True, symbol="-")
 
+        router_step_id = str(uuid4())
+
         self._prepare_steps()
 
         # Route to appropriate steps
@@ -341,7 +399,13 @@ class Router:
         log_debug(f"Router {self.name} selected: {len(steps_to_execute)} steps to execute")
 
         if not steps_to_execute:
-            return []
+            return StepOutput(
+                step_name=self.name,
+                step_id=router_step_id,
+                step_type=StepType.ROUTER,
+                content=f"Router {self.name} completed with 0 results (no steps selected)",
+                success=True,
+            )
 
         # Chain steps sequentially like Loop does
         all_results: List[StepOutput] = []
@@ -350,7 +414,14 @@ class Router:
 
         for i, step in enumerate(steps_to_execute):
             try:
-                step_output = await step.aexecute(current_step_input, session_id=session_id, user_id=user_id)
+                step_output = await step.aexecute(
+                    current_step_input,
+                    session_id=session_id,
+                    user_id=user_id,
+                    workflow_run_response=workflow_run_response,
+                    store_executor_outputs=store_executor_outputs,
+                    session_state=session_state,
+                )
                 # Handle both single StepOutput and List[StepOutput]
                 if isinstance(step_output, list):
                     all_results.extend(step_output)
@@ -390,22 +461,35 @@ class Router:
                 break  # Stop on first error
 
         log_debug(f"Router End: {self.name} ({len(all_results)} results)", center=True, symbol="-")
-        return all_results
+
+        return StepOutput(
+            step_name=self.name,
+            step_id=router_step_id,
+            step_type=StepType.ROUTER,
+            content=f"Router {self.name} completed with {len(all_results)} results",
+            success=all(result.success for result in all_results) if all_results else True,
+            steps=all_results,
+        )
 
     async def aexecute_stream(
         self,
         step_input: StepInput,
         session_id: Optional[str] = None,
         user_id: Optional[str] = None,
+        session_state: Optional[Dict[str, Any]] = None,
         stream_intermediate_steps: bool = False,
-        workflow_run_response: Optional[WorkflowRunResponse] = None,
+        workflow_run_response: Optional[WorkflowRunOutput] = None,
         step_index: Optional[Union[int, tuple]] = None,
-    ) -> AsyncIterator[Union[WorkflowRunResponseEvent, TeamRunResponseEvent, RunResponseEvent, StepOutput]]:
+        store_executor_outputs: bool = True,
+        parent_step_id: Optional[str] = None,
+    ) -> AsyncIterator[Union[WorkflowRunOutputEvent, TeamRunOutputEvent, RunOutputEvent, StepOutput]]:
         """Async execute the router with streaming support"""
         log_debug(f"Router Start: {self.name}", center=True, symbol="-")
 
         self._prepare_steps()
 
+        router_step_id = str(uuid4())
+
         # Route to appropriate steps
         steps_to_execute = await self._aroute_steps(step_input)
         log_debug(f"Router {self.name} selected: {len(steps_to_execute)} steps to execute")
@@ -420,6 +504,8 @@ class Router:
                 step_name=self.name,
                 step_index=step_index,
                 selected_steps=[getattr(step, "name", f"step_{i}") for i, step in enumerate(steps_to_execute)],
+                step_id=router_step_id,
+                parent_step_id=parent_step_id,
             )
 
         if not steps_to_execute:
@@ -435,6 +521,8 @@ class Router:
                     selected_steps=[],
                     executed_steps=0,
                     step_results=[],
+                    step_id=router_step_id,
+                    parent_step_id=parent_step_id,
                 )
             return
 
@@ -455,6 +543,9 @@ class Router:
                     stream_intermediate_steps=stream_intermediate_steps,
                     workflow_run_response=workflow_run_response,
                     step_index=step_index,
+                    store_executor_outputs=store_executor_outputs,
+                    session_state=session_state,
+                    parent_step_id=router_step_id,
                 ):
                     if isinstance(event, StepOutput):
                         step_outputs_for_step.append(event)
@@ -515,7 +606,17 @@ class Router:
                 selected_steps=[getattr(step, "name", f"step_{i}") for i, step in enumerate(steps_to_execute)],
                 executed_steps=len(steps_to_execute),
                 step_results=all_results,
+                step_id=router_step_id,
+                parent_step_id=parent_step_id,
             )
 
-        for result in all_results:
-            yield result
+        yield StepOutput(
+            step_name=self.name,
+            step_id=router_step_id,
+            step_type=StepType.ROUTER,
+            content=f"Router {self.name} completed with {len(all_results)} results",
+            success=all(result.success for result in all_results) if all_results else True,
+            error=None,
+            stop=False,
+            steps=all_results,
+        )