agno 1.8.2__py3-none-any.whl → 2.0.0__py3-none-any.whl

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

@@ -2,20 +2,21 @@ import asyncio
 from concurrent.futures import ThreadPoolExecutor, as_completed
 from dataclasses import dataclass
 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.models.metrics import Metrics
+from agno.run.agent import RunOutputEvent
+from agno.run.team import TeamRunOutputEvent
+from agno.run.workflow import (
     ParallelExecutionCompletedEvent,
     ParallelExecutionStartedEvent,
-    WorkflowRunResponse,
-    WorkflowRunResponseEvent,
+    WorkflowRunOutput,
+    WorkflowRunOutputEvent,
 )
 from agno.utils.log import log_debug, logger
-from agno.workflow.v2.condition import Condition
-from agno.workflow.v2.step import Step
-from agno.workflow.v2.steps import Steps
-from agno.workflow.v2.types import StepInput, StepOutput
+from agno.workflow.condition import Condition
+from agno.workflow.step import Step
+from agno.workflow.types import StepInput, StepOutput, StepType
 
 WorkflowSteps = List[
     Union[
@@ -55,10 +56,10 @@ class Parallel:
         """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.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.router import Router
+        from agno.workflow.step import Step
+        from agno.workflow.steps import Steps
 
         prepared_steps: WorkflowSteps = []
         for step in self.steps:
@@ -78,23 +79,25 @@ class Parallel:
     def _aggregate_results(self, step_outputs: List[StepOutput]) -> StepOutput:
         """Aggregate multiple step outputs into a single StepOutput"""
         if not step_outputs:
-            return StepOutput(step_name=self.name or "Parallel", content="No parallel steps executed")
-
-        # To store the individual step outputs for each parallel step
-        parallel_step_outputs = {output.step_name or f"step_{i}": output for i, output in enumerate(step_outputs)}
+            return StepOutput(
+                step_name=self.name or "Parallel",
+                step_id=str(uuid4()),
+                step_type="Parallel",
+                content="No parallel steps executed",
+                steps=[],
+            )
 
         if len(step_outputs) == 1:
-            # Single result, update the step name but preserve parallel structure
+            # Single result, but still create a Parallel container
             single_result = step_outputs[0]
-
-            # Extract metrics using the dedicated method
             aggregated_metrics = self._extract_metrics_from_response(step_outputs)
 
             return StepOutput(
                 step_name=self.name or "Parallel",
-                content=single_result.content,
-                parallel_step_outputs=parallel_step_outputs,
-                response=single_result.response,
+                step_id=str(uuid4()),
+                step_type=StepType.PARALLEL,
+                content=f"Parallel {self.name or 'execution'} completed with 1 result",
+                executor_name=self.name or "Parallel",
                 images=single_result.images,
                 videos=single_result.videos,
                 audio=single_result.audio,
@@ -102,12 +105,13 @@ class Parallel:
                 success=single_result.success,
                 error=single_result.error,
                 stop=single_result.stop,
+                steps=step_outputs,  # This is the key addition
             )
 
         early_termination_requested = any(output.stop for output in step_outputs if hasattr(output, "stop"))
 
         # Multiple results - aggregate them
-        aggregated_content = self._build_aggregated_content(step_outputs)
+        aggregated_content = f"Parallel {self.name or 'execution'} completed with {len(step_outputs)} results"
 
         # Combine all media from parallel steps
         all_images = []
@@ -127,63 +131,42 @@ class Parallel:
 
         return StepOutput(
             step_name=self.name or "Parallel",
+            step_id=str(uuid4()),
+            step_type=StepType.PARALLEL,
+            executor_type="parallel",
+            executor_name=self.name or "Parallel",
             content=aggregated_content,
-            parallel_step_outputs=parallel_step_outputs,
             images=all_images if all_images else None,
             videos=all_videos if all_videos else None,
             audio=all_audio if all_audio else None,
             success=not has_any_failure,
             stop=early_termination_requested,
             metrics=aggregated_metrics,
+            steps=step_outputs,
         )
 
-    def _extract_metrics_from_response(self, step_outputs: List[StepOutput]) -> Optional[Dict[str, Any]]:
+    def _extract_metrics_from_response(self, step_outputs: List[StepOutput]) -> Optional[Metrics]:
         """Extract and aggregate metrics from parallel step outputs"""
         if not step_outputs:
             return None
 
-        parallel_step_metrics = {}
+        # Aggregate metrics from all parallel step outputs
+        total_metrics = Metrics()
 
         for result in step_outputs:
-            step_name = result.step_name or "unknown"
-
-            # Create clean step metrics for parallel steps
             if result.metrics:
-                # If the step already has structured metrics, extract the actual metrics
-                if isinstance(result.metrics, dict) and "metrics" in result.metrics:
-                    actual_metrics = result.metrics.get("metrics")
-                    executor_type = result.metrics.get("executor_type", "unknown")
-                    executor_name = result.metrics.get("executor_name", "unknown")
-                else:
-                    actual_metrics = result.metrics
-                    executor_type = getattr(result, "executor_type", "unknown")
-                    executor_name = getattr(result, "executor_name", "unknown")
-
-                parallel_step_metrics[step_name] = {
-                    "step_name": step_name,
-                    "executor_type": executor_type,
-                    "executor_name": executor_name,
-                    "metrics": actual_metrics,
-                }
-            else:
-                # Even if no metrics, record the step execution
-                parallel_step_metrics[step_name] = {
-                    "step_name": step_name,
-                    "executor_type": getattr(result, "executor_type", "unknown"),
-                    "executor_name": getattr(result, "executor_name", "unknown"),
-                    "metrics": None,
-                }
-
-        # Create aggregated metrics structure for parallel execution
-        if parallel_step_metrics:
-            return {
-                "step_name": self.name or "Parallel",
-                "executor_type": "parallel",
-                "executor_name": self.name or "Parallel",
-                "parallel_steps": parallel_step_metrics,
-            }
+                total_metrics = total_metrics + result.metrics
+
+        # If no metrics were found, return None
+        if (
+            total_metrics.input_tokens == 0
+            and total_metrics.output_tokens == 0
+            and total_metrics.total_tokens == 0
+            and total_metrics.duration is None
+        ):
+            return None
 
-        return None
+        return total_metrics
 
     def _build_aggregated_content(self, step_outputs: List[StepOutput]) -> str:
         """Build aggregated content from multiple step outputs"""
@@ -212,6 +195,9 @@ class Parallel:
         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 all steps in parallel and return aggregated result"""
         # Use workflow logger for parallel orchestration
@@ -221,17 +207,27 @@ class Parallel:
 
         def execute_step_with_index(step_with_index):
             """Execute a single step and preserve its original index"""
-            index, step = step_with_index
+            idx, step = step_with_index
             try:
-                result = step.execute(step_input, session_id=session_id, user_id=user_id)  # type: ignore[union-attr]
-                return (index, result)
-            except Exception as e:
-                step_name = getattr(step, "name", f"step_{index}")
-                logger.error(f"Parallel step {step_name} failed: {e}")
+                step_result = step.execute(
+                    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,
+                )  # type: ignore[union-attr]
+                return idx, step_result
+            except Exception as exc:
+                parallel_step_name = getattr(step, "name", f"step_{idx}")
+                logger.error(f"Parallel step {parallel_step_name} failed: {exc}")
                 return (
-                    index,
+                    idx,
                     StepOutput(
-                        step_name=step_name, content=f"Step {step_name} failed: {str(e)}", success=False, error=str(e)
+                        step_name=parallel_step_name,
+                        content=f"Step {parallel_step_name} failed: {str(exc)}",
+                        success=False,
+                        error=str(exc),
                     ),
                 )
 
@@ -295,12 +291,17 @@ class Parallel:
         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 all steps in parallel with streaming support"""
         log_debug(f"Parallel Start: {self.name} ({len(self.steps)} steps)", center=True, symbol="=")
 
+        parallel_step_id = str(uuid4())
+
         self._prepare_steps()
 
         if stream_intermediate_steps and workflow_run_response:
@@ -313,19 +314,21 @@ class Parallel:
                 step_name=self.name,
                 step_index=step_index,
                 parallel_step_count=len(self.steps),
+                step_id=parallel_step_id,
+                parent_step_id=parent_step_id,
             )
 
         def execute_step_stream_with_index(step_with_index):
             """Execute a single step with streaming and preserve its original index"""
-            index, step = step_with_index
+            idx, step = step_with_index
             try:
-                events = []
+                step_events = []
 
                 # If step_index is None or integer (main step): create (step_index, sub_index)
                 # If step_index is tuple (child step): all parallel sub-steps get same index
                 if step_index is None or isinstance(step_index, int):
                     # Parallel is a main step - sub-steps get sequential numbers: 1.1, 1.2, 1.3
-                    sub_step_index = (step_index if step_index is not None else 0, index)
+                    sub_step_index = (step_index if step_index is not None else 0, idx)
                 else:
                     # Parallel is a child step - all sub-steps get the same parent number: 1.1, 1.1, 1.1
                     sub_step_index = step_index
@@ -338,20 +341,23 @@ class Parallel:
                     stream_intermediate_steps=stream_intermediate_steps,
                     workflow_run_response=workflow_run_response,
                     step_index=sub_step_index,
+                    store_executor_outputs=store_executor_outputs,
+                    session_state=session_state,
+                    parent_step_id=parallel_step_id,
                 ):
-                    events.append(event)
-                return (index, events)
-            except Exception as e:
-                step_name = getattr(step, "name", f"step_{index}")
-                logger.error(f"Parallel step {step_name} streaming failed: {e}")
+                    step_events.append(event)
+                return idx, step_events
+            except Exception as exc:
+                parallel_step_name = getattr(step, "name", f"step_{idx}")
+                logger.error(f"Parallel step {parallel_step_name} streaming failed: {exc}")
                 return (
-                    index,
+                    idx,
                     [
                         StepOutput(
-                            step_name=step_name,
-                            content=f"Step {step_name} failed: {str(e)}",
+                            step_name=parallel_step_name,
+                            content=f"Step {parallel_step_name} failed: {str(exc)}",
                             success=False,
-                            error=str(e),
+                            error=str(exc),
                         )
                     ],
                 )
@@ -431,6 +437,8 @@ class Parallel:
                 step_index=step_index,
                 parallel_step_count=len(self.steps),
                 step_results=[aggregated_result],  # Now single aggregated result
+                step_id=parallel_step_id,
+                parent_step_id=parent_step_id,
             )
 
     async def aexecute(
@@ -438,6 +446,9 @@ class Parallel:
         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 all steps in parallel using asyncio and return aggregated result"""
         # Use workflow logger for async parallel orchestration
@@ -447,20 +458,27 @@ class Parallel:
 
         async def execute_step_async_with_index(step_with_index):
             """Execute a single step asynchronously and preserve its original index"""
-            index, step = step_with_index
+            idx, step = step_with_index
             try:
-                result = await step.aexecute(step_input, session_id=session_id, user_id=user_id)  # type: ignore[union-attr]
-                return (index, result)
-            except Exception as e:
-                step_name = getattr(step, "name", f"step_{index}")
-                logger.error(f"Parallel step {step_name} failed: {e}")
+                inner_step_result = await step.aexecute(
+                    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,
+                )  # type: ignore[union-attr]
+                return idx, inner_step_result
+            except Exception as exc:
+                parallel_step_name = getattr(step, "name", f"step_{idx}")
+                logger.error(f"Parallel step {parallel_step_name} failed: {exc}")
                 return (
-                    index,
+                    idx,
                     StepOutput(
-                        step_name=step_name,
-                        content=f"Step {step_name} failed: {str(e)}",
+                        step_name=parallel_step_name,
+                        content=f"Step {parallel_step_name} failed: {str(exc)}",
                         success=False,
-                        error=str(e),
+                        error=str(exc),
                     ),
                 )
 
@@ -522,12 +540,17 @@ class Parallel:
         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 all steps in parallel with async streaming support"""
         log_debug(f"Parallel Start: {self.name} ({len(self.steps)} steps)", center=True, symbol="=")
 
+        parallel_step_id = str(uuid4())
+
         self._prepare_steps()
 
         if stream_intermediate_steps and workflow_run_response:
@@ -540,19 +563,21 @@ class Parallel:
                 step_name=self.name,
                 step_index=step_index,
                 parallel_step_count=len(self.steps),
+                step_id=parallel_step_id,
+                parent_step_id=parent_step_id,
             )
 
         async def execute_step_stream_async_with_index(step_with_index):
             """Execute a single step with async streaming and preserve its original index"""
-            index, step = step_with_index
+            idx, step = step_with_index
             try:
-                events = []
+                step_events = []
 
                 # If step_index is None or integer (main step): create (step_index, sub_index)
                 # If step_index is tuple (child step): all parallel sub-steps get same index
                 if step_index is None or isinstance(step_index, int):
                     # Parallel is a main step - sub-steps get sequential numbers: 1.1, 1.2, 1.3
-                    sub_step_index = (step_index if step_index is not None else 0, index)
+                    sub_step_index = (step_index if step_index is not None else 0, idx)
                 else:
                     # Parallel is a child step - all sub-steps get the same parent number: 1.1, 1.1, 1.1
                     sub_step_index = step_index
@@ -565,18 +590,21 @@ class Parallel:
                     stream_intermediate_steps=stream_intermediate_steps,
                     workflow_run_response=workflow_run_response,
                     step_index=sub_step_index,
+                    store_executor_outputs=store_executor_outputs,
+                    session_state=session_state,
+                    parent_step_id=parallel_step_id,
                 ):  # type: ignore[union-attr]
-                    events.append(event)
-                return (index, events)
+                    step_events.append(event)
+                return idx, step_events
             except Exception as e:
-                step_name = getattr(step, "name", f"step_{index}")
-                logger.error(f"Parallel step {step_name} async streaming failed: {e}")
+                parallel_step_name = getattr(step, "name", f"step_{idx}")
+                logger.error(f"Parallel step {parallel_step_name} async streaming failed: {e}")
                 return (
-                    index,
+                    idx,
                     [
                         StepOutput(
-                            step_name=step_name,
-                            content=f"Step {step_name} failed: {str(e)}",
+                            step_name=parallel_step_name,
+                            content=f"Step {parallel_step_name} failed: {str(e)}",
                             success=False,
                             error=str(e),
                         )
@@ -656,4 +684,6 @@ class Parallel:
                 step_index=step_index,
                 parallel_step_count=len(self.steps),
                 step_results=[aggregated_result],  # Now single aggregated result
+                step_id=parallel_step_id,
+                parent_step_id=parent_step_id,
             )