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

agno/workflow/{v2/condition.py → condition.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 (
     ConditionExecutionCompletedEvent,
     ConditionExecutionStartedEvent,
-    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[
@@ -48,11 +49,11 @@ class Condition:
         """Prepare the steps for execution - mirrors workflow logic"""
         from agno.agent.agent import Agent
         from agno.team.team import Team
-        from agno.workflow.v2.loop import Loop
-        from agno.workflow.v2.parallel import Parallel
-        from agno.workflow.v2.router import Router
-        from agno.workflow.v2.step import Step
-        from agno.workflow.v2.steps import Steps
+        from agno.workflow.loop import Loop
+        from agno.workflow.parallel import Parallel
+        from agno.workflow.router import Router
+        from agno.workflow.step import Step
+        from agno.workflow.steps import Steps
 
         prepared_steps: WorkflowSteps = []
         for step in self.steps:
@@ -100,7 +101,7 @@ class Condition:
             updated_previous_step_outputs.update(condition_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,
@@ -145,11 +146,19 @@ class Condition:
         return False
 
     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,
+        store_executor_outputs: bool = True,
+        session_state: Optional[Dict[str, Any]] = None,
+    ) -> StepOutput:
         """Execute the condition and its steps with sequential chaining if condition is true"""
         log_debug(f"Condition Start: {self.name}", center=True, symbol="-")
 
+        conditional_step_id = str(uuid4())
+
         self._prepare_steps()
 
         # Evaluate the condition
@@ -158,7 +167,13 @@ class Condition:
 
         if not condition_result:
             log_debug(f"Condition {self.name} not met, skipping {len(self.steps)} steps")
-            return []
+            return StepOutput(
+                step_name=self.name,
+                step_id=conditional_step_id,
+                step_type=StepType.CONDITION,
+                content=f"Condition {self.name} not met - skipped {len(self.steps)} steps",
+                success=True,
+            )
 
         log_debug(f"Condition {self.name} met, executing {len(self.steps)} steps")
         all_results: List[StepOutput] = []
@@ -167,7 +182,14 @@ class Condition:
 
         for i, step in enumerate(self.steps):
             try:
-                step_output = step.execute(current_step_input, session_id=session_id, user_id=user_id)  # type: ignore[union-attr]
+                step_output = step.execute(  # type: ignore[union-attr]
+                    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] (from Loop/Condition/Router steps)
                 if isinstance(step_output, list):
@@ -210,7 +232,17 @@ class Condition:
                 break
 
         log_debug(f"Condition End: {self.name} ({len(all_results)} results)", center=True, symbol="-")
-        return all_results
+
+        return StepOutput(
+            step_name=self.name,
+            step_id=conditional_step_id,
+            step_type=StepType.CONDITION,
+            content=f"Condition {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,
+        )
 
     def execute_stream(
         self,
@@ -218,12 +250,17 @@ class Condition:
         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,
         step_index: Optional[Union[int, tuple]] = None,
-    ) -> Iterator[Union[WorkflowRunResponseEvent, StepOutput]]:
+        store_executor_outputs: bool = True,
+        session_state: Optional[Dict[str, Any]] = None,
+        parent_step_id: Optional[str] = None,
+    ) -> Iterator[Union[WorkflowRunOutputEvent, StepOutput]]:
         """Execute the condition with streaming support - mirrors Loop logic"""
         log_debug(f"Condition Start: {self.name}", center=True, symbol="-")
 
+        conditional_step_id = str(uuid4())
+
         self._prepare_steps()
 
         # Evaluate the condition
@@ -240,6 +277,8 @@ class Condition:
                 step_name=self.name,
                 step_index=step_index,
                 condition_result=condition_result,
+                step_id=conditional_step_id,
+                parent_step_id=parent_step_id,
             )
 
         if not condition_result:
@@ -255,6 +294,8 @@ class Condition:
                     condition_result=False,
                     executed_steps=0,
                     step_results=[],
+                    step_id=conditional_step_id,
+                    parent_step_id=parent_step_id,
                 )
             return
 
@@ -283,6 +324,9 @@ class Condition:
                     stream_intermediate_steps=stream_intermediate_steps,
                     workflow_run_response=workflow_run_response,
                     step_index=child_step_index,
+                    store_executor_outputs=store_executor_outputs,
+                    session_state=session_state,
+                    parent_step_id=conditional_step_id,
                 ):
                     if isinstance(event, StepOutput):
                         step_outputs_for_step.append(event)
@@ -342,17 +386,33 @@ class Condition:
                 condition_result=True,
                 executed_steps=len(self.steps),
                 step_results=all_results,
+                step_id=conditional_step_id,
+                parent_step_id=parent_step_id,
             )
 
-        for result in all_results:
-            yield result
+        yield StepOutput(
+            step_name=self.name,
+            step_id=conditional_step_id,
+            step_type=StepType.CONDITION,
+            content=f"Condition {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,
+        store_executor_outputs: bool = True,
+        session_state: Optional[Dict[str, Any]] = None,
+    ) -> StepOutput:
         """Async execute the condition and its steps with sequential chaining"""
         log_debug(f"Condition Start: {self.name}", center=True, symbol="-")
 
+        conditional_step_id = str(uuid4())
+
         self._prepare_steps()
 
         # Evaluate the condition
@@ -361,7 +421,13 @@ class Condition:
 
         if not condition_result:
             log_debug(f"Condition {self.name} not met, skipping {len(self.steps)} steps")
-            return []
+            return StepOutput(
+                step_name=self.name,
+                step_id=str(uuid4()),
+                step_type=StepType.CONDITION,
+                content=f"Condition {self.name} not met - skipped {len(self.steps)} steps",
+                success=True,
+            )
 
         log_debug(f"Condition {self.name} met, executing {len(self.steps)} steps")
 
@@ -372,7 +438,14 @@ class Condition:
 
         for i, step in enumerate(self.steps):
             try:
-                step_output = await step.aexecute(current_step_input, session_id=session_id, user_id=user_id)  # type: ignore[union-attr]
+                step_output = await step.aexecute(  # type: ignore[union-attr]
+                    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):
@@ -413,7 +486,17 @@ class Condition:
                 break
 
         log_debug(f"Condition End: {self.name} ({len(all_results)} results)", center=True, symbol="-")
-        return all_results
+
+        return StepOutput(
+            step_name=self.name,
+            step_id=conditional_step_id,
+            step_type=StepType.CONDITION,
+            content=f"Condition {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,
+        )
 
     async def aexecute_stream(
         self,
@@ -421,12 +504,17 @@ class Condition:
         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,
         step_index: Optional[Union[int, tuple]] = None,
-    ) -> AsyncIterator[Union[WorkflowRunResponseEvent, TeamRunResponseEvent, RunResponseEvent, StepOutput]]:
+        store_executor_outputs: bool = True,
+        session_state: Optional[Dict[str, Any]] = None,
+        parent_step_id: Optional[str] = None,
+    ) -> AsyncIterator[Union[WorkflowRunOutputEvent, TeamRunOutputEvent, RunOutputEvent, StepOutput]]:
         """Async execute the condition with streaming support - mirrors Loop logic"""
         log_debug(f"Condition Start: {self.name}", center=True, symbol="-")
 
+        conditional_step_id = str(uuid4())
+
         self._prepare_steps()
 
         # Evaluate the condition
@@ -443,6 +531,8 @@ class Condition:
                 step_name=self.name,
                 step_index=step_index,
                 condition_result=condition_result,
+                step_id=conditional_step_id,
+                parent_step_id=parent_step_id,
             )
 
         if not condition_result:
@@ -458,6 +548,8 @@ class Condition:
                     condition_result=False,
                     executed_steps=0,
                     step_results=[],
+                    step_id=conditional_step_id,
+                    parent_step_id=parent_step_id,
                 )
             return
 
@@ -488,6 +580,9 @@ class Condition:
                     stream_intermediate_steps=stream_intermediate_steps,
                     workflow_run_response=workflow_run_response,
                     step_index=child_step_index,
+                    store_executor_outputs=store_executor_outputs,
+                    session_state=session_state,
+                    parent_step_id=conditional_step_id,
                 ):
                     if isinstance(event, StepOutput):
                         step_outputs_for_step.append(event)
@@ -548,7 +643,15 @@ class Condition:
                 condition_result=True,
                 executed_steps=len(self.steps),
                 step_results=all_results,
+                step_id=conditional_step_id,
+                parent_step_id=parent_step_id,
             )
 
-        for result in all_results:
-            yield result
+        yield StepOutput(
+            step_name=self.name,
+            step_id=conditional_step_id,
+            step_type=StepType.CONDITION,
+            content=f"Condition {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,
+        )

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

@@ -1,20 +1,21 @@
 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 (
     LoopExecutionCompletedEvent,
     LoopExecutionStartedEvent,
     LoopIterationCompletedEvent,
     LoopIterationStartedEvent,
-    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[
@@ -61,11 +62,11 @@ class Loop:
         """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.parallel import Parallel
-        from agno.workflow.v2.router import Router
-        from agno.workflow.v2.step import Step
-        from agno.workflow.v2.steps import Steps
+        from agno.workflow.condition import Condition
+        from agno.workflow.parallel import Parallel
+        from agno.workflow.router import Router
+        from agno.workflow.step import Step
+        from agno.workflow.steps import Steps
 
         prepared_steps: WorkflowSteps = []
         for step in self.steps:
@@ -114,7 +115,7 @@ class Loop:
             updated_previous_step_outputs.update(loop_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,
@@ -128,7 +129,10 @@ class Loop:
         step_input: StepInput,
         session_id: Optional[str] = None,
         user_id: Optional[str] = None,
-    ) -> List[StepOutput]:
+        workflow_run_response: Optional[WorkflowRunOutput] = None,
+        store_executor_outputs: bool = True,
+        session_state: Optional[Dict[str, Any]] = None,
+    ) -> StepOutput:
         """Execute loop steps with iteration control - mirrors workflow execution logic"""
         # Use workflow logger for loop orchestration
         log_debug(f"Loop Start: {self.name}", center=True, symbol="=")
@@ -146,7 +150,14 @@ class Loop:
             loop_step_outputs = {}  # Track outputs within this loop iteration
 
             for i, step in enumerate(self.steps):
-                step_output = step.execute(current_step_input, session_id=session_id, user_id=user_id)  # type: ignore[union-attr]
+                step_output = step.execute(  # type: ignore[union-attr]
+                    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] (from Loop/Condition steps)
                 if isinstance(step_output, list):
@@ -194,7 +205,14 @@ class Loop:
         for iteration_results in all_results:
             flattened_results.extend(iteration_results)
 
-        return flattened_results
+        return StepOutput(
+            step_name=self.name,
+            step_id=str(uuid4()),
+            step_type=StepType.LOOP,
+            content=f"Loop {self.name} completed {iteration} iterations with {len(flattened_results)} total steps",
+            success=all(result.success for result in flattened_results) if flattened_results else True,
+            steps=flattened_results,
+        )
 
     def execute_stream(
         self,
@@ -202,15 +220,20 @@ class Loop:
         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,
         step_index: Optional[Union[int, tuple]] = None,
-    ) -> Iterator[Union[WorkflowRunResponseEvent, StepOutput]]:
+        store_executor_outputs: bool = True,
+        session_state: Optional[Dict[str, Any]] = None,
+        parent_step_id: Optional[str] = None,
+    ) -> Iterator[Union[WorkflowRunOutputEvent, StepOutput]]:
         """Execute loop steps with streaming support - mirrors workflow execution logic"""
         log_debug(f"Loop Start: {self.name}", center=True, symbol="=")
 
         # Prepare steps first
         self._prepare_steps()
 
+        loop_step_id = str(uuid4())
+
         if stream_intermediate_steps and workflow_run_response:
             # Yield loop started event
             yield LoopExecutionStartedEvent(
@@ -221,6 +244,8 @@ class Loop:
                 step_name=self.name,
                 step_index=step_index,
                 max_iterations=self.max_iterations,
+                step_id=loop_step_id,
+                parent_step_id=parent_step_id,
             )
 
         all_results = []
@@ -241,6 +266,8 @@ class Loop:
                     step_index=step_index,
                     iteration=iteration + 1,
                     max_iterations=self.max_iterations,
+                    step_id=loop_step_id,
+                    parent_step_id=parent_step_id,
                 )
 
             # Execute all steps in this iteration - mirroring workflow logic
@@ -267,6 +294,9 @@ class Loop:
                     stream_intermediate_steps=stream_intermediate_steps,
                     workflow_run_response=workflow_run_response,
                     step_index=composite_step_index,
+                    store_executor_outputs=store_executor_outputs,
+                    session_state=session_state,
+                    parent_step_id=loop_step_id,
                 ):
                     if isinstance(event, StepOutput):
                         step_outputs_for_iteration.append(event)
@@ -331,6 +361,8 @@ class Loop:
                     max_iterations=self.max_iterations,
                     iteration_results=iteration_results,
                     should_continue=should_continue,
+                    step_id=loop_step_id,
+                    parent_step_id=parent_step_id,
                 )
 
             iteration += 1
@@ -353,22 +385,38 @@ class Loop:
                 total_iterations=iteration,
                 max_iterations=self.max_iterations,
                 all_results=all_results,
+                step_id=loop_step_id,
+                parent_step_id=parent_step_id,
             )
 
+        flattened_results = []
         for iteration_results in all_results:
-            for step_output in iteration_results:
-                yield step_output
+            flattened_results.extend(iteration_results)
+
+        yield StepOutput(
+            step_name=self.name,
+            step_id=loop_step_id,
+            step_type=StepType.LOOP,
+            content=f"Loop {self.name} completed {iteration} iterations with {len(flattened_results)} total steps",
+            success=all(result.success for result in flattened_results) if flattened_results else True,
+            steps=flattened_results,
+        )
 
     async def aexecute(
         self,
         step_input: StepInput,
         session_id: Optional[str] = None,
         user_id: Optional[str] = None,
-    ) -> List[StepOutput]:
+        workflow_run_response: Optional[WorkflowRunOutput] = None,
+        store_executor_outputs: bool = True,
+        session_state: Optional[Dict[str, Any]] = None,
+    ) -> StepOutput:
         """Execute loop steps asynchronously with iteration control - mirrors workflow execution logic"""
         # Use workflow logger for async loop orchestration
         log_debug(f"Loop Start: {self.name}", center=True, symbol="=")
 
+        loop_step_id = str(uuid4())
+
         # Prepare steps first
         self._prepare_steps()
 
@@ -382,7 +430,14 @@ class Loop:
             loop_step_outputs = {}  # Track outputs within this loop iteration
 
             for i, step in enumerate(self.steps):
-                step_output = await step.aexecute(current_step_input, session_id=session_id, user_id=user_id)  # type: ignore[union-attr]
+                step_output = await step.aexecute(  # type: ignore[union-attr]
+                    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] (from Loop/Condition steps)
                 if isinstance(step_output, list):
@@ -433,7 +488,14 @@ class Loop:
         for iteration_results in all_results:
             flattened_results.extend(iteration_results)
 
-        return flattened_results
+        return StepOutput(
+            step_name=self.name,
+            step_id=loop_step_id,
+            step_type=StepType.LOOP,
+            content=f"Loop {self.name} completed {iteration} iterations with {len(flattened_results)} total steps",
+            success=all(result.success for result in flattened_results) if flattened_results else True,
+            steps=flattened_results,
+        )
 
     async def aexecute_stream(
         self,
@@ -441,12 +503,17 @@ class Loop:
         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,
         step_index: Optional[Union[int, tuple]] = None,
-    ) -> AsyncIterator[Union[WorkflowRunResponseEvent, TeamRunResponseEvent, RunResponseEvent, StepOutput]]:
+        store_executor_outputs: bool = True,
+        session_state: Optional[Dict[str, Any]] = None,
+        parent_step_id: Optional[str] = None,
+    ) -> AsyncIterator[Union[WorkflowRunOutputEvent, TeamRunOutputEvent, RunOutputEvent, StepOutput]]:
         """Execute loop steps with async streaming support - mirrors workflow execution logic"""
         log_debug(f"Loop Start: {self.name}", center=True, symbol="=")
 
+        loop_step_id = str(uuid4())
+
         # Prepare steps first
         self._prepare_steps()
 
@@ -460,6 +527,8 @@ class Loop:
                 step_name=self.name,
                 step_index=step_index,
                 max_iterations=self.max_iterations,
+                step_id=loop_step_id,
+                parent_step_id=parent_step_id,
             )
 
         all_results = []
@@ -480,6 +549,8 @@ class Loop:
                     step_index=step_index,
                     iteration=iteration + 1,
                     max_iterations=self.max_iterations,
+                    step_id=loop_step_id,
+                    parent_step_id=parent_step_id,
                 )
 
             # Execute all steps in this iteration - mirroring workflow logic
@@ -506,6 +577,9 @@ class Loop:
                     stream_intermediate_steps=stream_intermediate_steps,
                     workflow_run_response=workflow_run_response,
                     step_index=composite_step_index,
+                    store_executor_outputs=store_executor_outputs,
+                    session_state=session_state,
+                    parent_step_id=loop_step_id,
                 ):
                     if isinstance(event, StepOutput):
                         step_outputs_for_iteration.append(event)
@@ -573,6 +647,8 @@ class Loop:
                     max_iterations=self.max_iterations,
                     iteration_results=iteration_results,
                     should_continue=should_continue,
+                    step_id=loop_step_id,
+                    parent_step_id=parent_step_id,
                 )
 
             iteration += 1
@@ -595,8 +671,19 @@ class Loop:
                 total_iterations=iteration,
                 max_iterations=self.max_iterations,
                 all_results=all_results,
+                step_id=loop_step_id,
+                parent_step_id=parent_step_id,
             )
 
+        flattened_results = []
         for iteration_results in all_results:
-            for step_output in iteration_results:
-                yield step_output
+            flattened_results.extend(iteration_results)
+
+        yield StepOutput(
+            step_name=self.name,
+            step_id=loop_step_id,
+            step_type=StepType.LOOP,
+            content=f"Loop {self.name} completed {iteration} iterations with {len(flattened_results)} total steps",
+            success=all(result.success for result in flattened_results) if flattened_results else True,
+            steps=flattened_results,
+        )