agno 2.1.2__py3-none-any.whl → 2.3.13__py3-none-any.whl

agno/workflow/parallel.py

@@ -1,5 +1,7 @@
 import asyncio
+import warnings
 from concurrent.futures import ThreadPoolExecutor, as_completed
+from contextvars import copy_context
 from copy import deepcopy
 from dataclasses import dataclass
 from typing import Any, AsyncIterator, Awaitable, Callable, Dict, Iterator, List, Optional, Union
@@ -7,6 +9,7 @@ from uuid import uuid4
 
 from agno.models.metrics import Metrics
 from agno.run.agent import RunOutputEvent
+from agno.run.base import RunContext
 from agno.run.team import TeamRunOutputEvent
 from agno.run.workflow import (
     ParallelExecutionCompletedEvent,
@@ -14,8 +17,9 @@ from agno.run.workflow import (
     WorkflowRunOutput,
     WorkflowRunOutputEvent,
 )
-from agno.utils.merge_dict import merge_parallel_session_states
+from agno.session.workflow import WorkflowSession
 from agno.utils.log import log_debug, logger
+from agno.utils.merge_dict import merge_parallel_session_states
 from agno.workflow.condition import Condition
 from agno.workflow.step import Step
 from agno.workflow.types import StepInput, StepOutput, StepType
@@ -98,7 +102,7 @@ class Parallel:
                 step_name=self.name or "Parallel",
                 step_id=str(uuid4()),
                 step_type=StepType.PARALLEL,
-                content=f"Parallel {self.name or 'execution'} completed with 1 result",
+                content=self._build_aggregated_content(step_outputs),
                 executor_name=self.name or "Parallel",
                 images=single_result.images,
                 videos=single_result.videos,
@@ -112,8 +116,8 @@ class Parallel:
 
         early_termination_requested = any(output.stop for output in step_outputs if hasattr(output, "stop"))
 
-        # Multiple results - aggregate them
-        aggregated_content = f"Parallel {self.name or 'execution'} completed with {len(step_outputs)} results"
+        # Multiple results - aggregate them with actual content from all steps
+        aggregated_content = self._build_aggregated_content(step_outputs)
 
         # Combine all media from parallel steps
         all_images = []
@@ -199,7 +203,12 @@ class Parallel:
         user_id: Optional[str] = None,
         workflow_run_response: Optional[WorkflowRunOutput] = None,
         store_executor_outputs: bool = True,
+        run_context: Optional[RunContext] = None,
         session_state: Optional[Dict[str, Any]] = None,
+        workflow_session: Optional[WorkflowSession] = None,
+        add_workflow_history_to_steps: Optional[bool] = False,
+        num_history_runs: int = 3,
+        background_tasks: Optional[Any] = None,
     ) -> StepOutput:
         """Execute all steps in parallel and return aggregated result"""
         # Use workflow logger for parallel orchestration
@@ -210,17 +219,21 @@ class Parallel:
         # Create individual session_state copies for each step to prevent race conditions
         session_state_copies = []
         for _ in range(len(self.steps)):
-            if session_state is not None:
-                session_state_copies.append(deepcopy(session_state))
+            # If using run context, no need to deepcopy the state. We want the direct reference.
+            if run_context is not None and run_context.session_state is not None:
+                session_state_copies.append(run_context.session_state)
             else:
-                session_state_copies.append({})
+                if session_state is not None:
+                    session_state_copies.append(deepcopy(session_state))
+                else:
+                    session_state_copies.append({})
 
         def execute_step_with_index(step_with_index):
             """Execute a single step and preserve its original index"""
             idx, step = step_with_index
             # Use the individual session_state copy for this step
             step_session_state = session_state_copies[idx]
-            
+
             try:
                 step_result = step.execute(
                     step_input,
@@ -228,7 +241,12 @@ class Parallel:
                     user_id=user_id,
                     workflow_run_response=workflow_run_response,
                     store_executor_outputs=store_executor_outputs,
+                    workflow_session=workflow_session,
+                    add_workflow_history_to_steps=add_workflow_history_to_steps,
+                    num_history_runs=num_history_runs,
+                    run_context=run_context,
                     session_state=step_session_state,
+                    background_tasks=background_tasks,
                 )  # type: ignore[union-attr]
                 return idx, step_result, step_session_state
             except Exception as exc:
@@ -250,8 +268,9 @@ class Parallel:
 
         with ThreadPoolExecutor(max_workers=len(self.steps)) as executor:
             # Submit all tasks with their original indices
+            # Use copy_context().run to propagate context variables to child threads
             future_to_index = {
-                executor.submit(execute_step_with_index, indexed_step): indexed_step[0]
+                executor.submit(copy_context().run, execute_step_with_index, indexed_step): indexed_step[0]
                 for indexed_step in indexed_steps
             }
 
@@ -281,7 +300,7 @@ class Parallel:
                         )
                     )
 
-        if session_state is not None:
+        if run_context is None and session_state is not None:
             merge_parallel_session_states(session_state, modified_session_states)
 
         # Sort by original index to preserve order
@@ -309,12 +328,19 @@ class Parallel:
         step_input: StepInput,
         session_id: Optional[str] = None,
         user_id: Optional[str] = None,
+        stream_events: bool = False,
         stream_intermediate_steps: bool = False,
+        stream_executor_events: bool = True,
         workflow_run_response: Optional[WorkflowRunOutput] = None,
         step_index: Optional[Union[int, tuple]] = None,
         store_executor_outputs: bool = True,
+        run_context: Optional[RunContext] = None,
         session_state: Optional[Dict[str, Any]] = None,
         parent_step_id: Optional[str] = None,
+        workflow_session: Optional[WorkflowSession] = None,
+        add_workflow_history_to_steps: Optional[bool] = False,
+        num_history_runs: int = 3,
+        background_tasks: Optional[Any] = 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="=")
@@ -326,12 +352,25 @@ class Parallel:
         # Create individual session_state copies for each step to prevent race conditions
         session_state_copies = []
         for _ in range(len(self.steps)):
-            if session_state is not None:
-                session_state_copies.append(deepcopy(session_state))
+            # If using run context, no need to deepcopy the state. We want the direct reference.
+            if run_context is not None and run_context.session_state is not None:
+                session_state_copies.append(run_context.session_state)
             else:
-                session_state_copies.append({})
+                if session_state is not None:
+                    session_state_copies.append(deepcopy(session_state))
+                else:
+                    session_state_copies.append({})
+
+        # Considering both stream_events and stream_intermediate_steps (deprecated)
+        if stream_intermediate_steps is not None:
+            warnings.warn(
+                "The 'stream_intermediate_steps' parameter is deprecated and will be removed in future versions. Use 'stream_events' instead.",
+                DeprecationWarning,
+                stacklevel=2,
+            )
+        stream_events = stream_events or stream_intermediate_steps
 
-        if stream_intermediate_steps and workflow_run_response:
+        if stream_events and workflow_run_response:
             # Yield parallel step started event
             yield ParallelExecutionStartedEvent(
                 run_id=workflow_run_response.run_id or "",
@@ -345,14 +384,20 @@ class Parallel:
                 parent_step_id=parent_step_id,
             )
 
+        import queue
+
+        event_queue = queue.Queue()  # type: ignore
+        step_results = []
+        modified_session_states = []
+
         def execute_step_stream_with_index(step_with_index):
-            """Execute a single step with streaming and preserve its original index"""
+            """Execute a single step with streaming and put events in queue immediately"""
             idx, step = step_with_index
             # Use the individual session_state copy for this step
             step_session_state = session_state_copies[idx]
-            
+
             try:
-                step_events = []
+                step_outputs = []
 
                 # 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
@@ -368,85 +413,94 @@ class Parallel:
                     step_input,
                     session_id=session_id,
                     user_id=user_id,
-                    stream_intermediate_steps=stream_intermediate_steps,
+                    stream_events=stream_events,
+                    stream_executor_events=stream_executor_events,
                     workflow_run_response=workflow_run_response,
                     step_index=sub_step_index,
                     store_executor_outputs=store_executor_outputs,
                     session_state=step_session_state,
+                    run_context=run_context,
                     parent_step_id=parallel_step_id,
+                    workflow_session=workflow_session,
+                    add_workflow_history_to_steps=add_workflow_history_to_steps,
+                    num_history_runs=num_history_runs,
+                    background_tasks=background_tasks,
                 ):
-                    step_events.append(event)
-                return idx, step_events, step_session_state
+                    # Put event immediately in queue
+                    event_queue.put(("event", idx, event))
+                    if isinstance(event, StepOutput):
+                        step_outputs.append(event)
+
+                # Signal completion for this step
+                event_queue.put(("complete", idx, step_outputs, step_session_state))
+                return idx, step_outputs, step_session_state
             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 (
-                    idx,
-                    [
-                        StepOutput(
-                            step_name=parallel_step_name,
-                            content=f"Step {parallel_step_name} failed: {str(exc)}",
-                            success=False,
-                            error=str(exc),
-                        )
-                    ],
-                    step_session_state,
+                error_event = StepOutput(
+                    step_name=parallel_step_name,
+                    content=f"Step {parallel_step_name} failed: {str(exc)}",
+                    success=False,
+                    error=str(exc),
                 )
+                event_queue.put(("event", idx, error_event))
+                event_queue.put(("complete", idx, [error_event], step_session_state))
+                return idx, [error_event], step_session_state
 
-        # Use index to preserve order
+        # Submit all parallel tasks
         indexed_steps = list(enumerate(self.steps))
-        all_events_with_indices = []
-        step_results = []
-        modified_session_states = []
 
         with ThreadPoolExecutor(max_workers=len(self.steps)) as executor:
-            # Submit all tasks with their original indices
-            future_to_index = {
-                executor.submit(execute_step_stream_with_index, indexed_step): indexed_step[0]
+            # Submit all tasks
+            # Use copy_context().run to propagate context variables to child threads
+            futures = [
+                executor.submit(copy_context().run, execute_step_stream_with_index, indexed_step)
                 for indexed_step in indexed_steps
-            }
+            ]
 
-            # Collect results and modified session_state copies
-            for future in as_completed(future_to_index):
+            # Process events from queue as they arrive
+            completed_steps = 0
+            total_steps = len(self.steps)
+
+            while completed_steps < total_steps:
                 try:
-                    index, events, modified_session_state = future.result()
-                    all_events_with_indices.append((index, events))
-                    modified_session_states.append(modified_session_state)
+                    message_type, step_idx, *data = event_queue.get(timeout=1.0)
+
+                    if message_type == "event":
+                        event = data[0]
+                        # Yield events immediately as they arrive (except StepOutputs)
+                        if not isinstance(event, StepOutput):
+                            yield event
 
-                    # Extract StepOutput from events for the final result
-                    step_outputs = [event for event in events if isinstance(event, StepOutput)]
-                    if step_outputs:
+                    elif message_type == "complete":
+                        step_outputs, step_session_state = data
                         step_results.extend(step_outputs)
+                        modified_session_states.append(step_session_state)
+                        completed_steps += 1
+
+                        step_name = getattr(self.steps[step_idx], "name", f"step_{step_idx}")
+                        log_debug(f"Parallel step {step_name} streaming completed")
+
+                except queue.Empty:
+                    for i, future in enumerate(futures):
+                        if future.done() and future.exception():
+                            logger.error(f"Parallel step {i} failed: {future.exception()}")
+                            if completed_steps < total_steps:
+                                completed_steps += 1
+                except Exception as e:
+                    logger.error(f"Error processing parallel step events: {e}")
+                    completed_steps += 1
 
-                    step_name = getattr(self.steps[index], "name", f"step_{index}")
-                    log_debug(f"Parallel step {step_name} streaming completed")
+            for future in futures:
+                try:
+                    future.result()
                 except Exception as e:
-                    index = future_to_index[future]
-                    step_name = getattr(self.steps[index], "name", f"step_{index}")
-                    logger.error(f"Parallel step {step_name} streaming failed: {e}")
-                    error_event = StepOutput(
-                        step_name=step_name,
-                        content=f"Step {step_name} failed: {str(e)}",
-                        success=False,
-                        error=str(e),
-                    )
-                    all_events_with_indices.append((index, [error_event]))
-                    step_results.append(error_event)
+                    logger.error(f"Future completion error: {e}")
 
         # Merge all session_state changes back into the original session_state
-        if session_state is not None:
+        if run_context is None and session_state is not None:
             merge_parallel_session_states(session_state, modified_session_states)
 
-        # Sort events by original index to preserve order
-        all_events_with_indices.sort(key=lambda x: x[0])
-
-        # Yield all collected streaming events in order (but not final StepOutputs)
-        for _, events in all_events_with_indices:
-            for event in events:
-                # Only yield non-StepOutput events during streaming to avoid duplication
-                if not isinstance(event, StepOutput):
-                    yield event
-
         # Flatten step_results - handle steps that return List[StepOutput] (like Condition/Loop)
         flattened_step_results: List[StepOutput] = []
         for result in step_results:
@@ -463,7 +517,7 @@ class Parallel:
 
         log_debug(f"Parallel End: {self.name} ({len(self.steps)} steps)", center=True, symbol="=")
 
-        if stream_intermediate_steps and workflow_run_response:
+        if stream_events and workflow_run_response:
             # Yield parallel step completed event
             yield ParallelExecutionCompletedEvent(
                 run_id=workflow_run_response.run_id or "",
@@ -473,7 +527,7 @@ class Parallel:
                 step_name=self.name,
                 step_index=step_index,
                 parallel_step_count=len(self.steps),
-                step_results=[aggregated_result],  # Now single aggregated result
+                step_results=flattened_step_results,
                 step_id=parallel_step_id,
                 parent_step_id=parent_step_id,
             )
@@ -485,7 +539,12 @@ class Parallel:
         user_id: Optional[str] = None,
         workflow_run_response: Optional[WorkflowRunOutput] = None,
         store_executor_outputs: bool = True,
+        run_context: Optional[RunContext] = None,
         session_state: Optional[Dict[str, Any]] = None,
+        workflow_session: Optional[WorkflowSession] = None,
+        add_workflow_history_to_steps: Optional[bool] = False,
+        num_history_runs: int = 3,
+        background_tasks: Optional[Any] = None,
     ) -> StepOutput:
         """Execute all steps in parallel using asyncio and return aggregated result"""
         # Use workflow logger for async parallel orchestration
@@ -496,17 +555,21 @@ class Parallel:
         # Create individual session_state copies for each step to prevent race conditions
         session_state_copies = []
         for _ in range(len(self.steps)):
-            if session_state is not None:
-                session_state_copies.append(deepcopy(session_state))
+            # If using run context, no need to deepcopy the state. We want the direct reference.
+            if run_context is not None and run_context.session_state is not None:
+                session_state_copies.append(run_context.session_state)
             else:
-                session_state_copies.append({})
+                if session_state is not None:
+                    session_state_copies.append(deepcopy(session_state))
+                else:
+                    session_state_copies.append({})
 
         async def execute_step_async_with_index(step_with_index):
             """Execute a single step asynchronously and preserve its original index"""
             idx, step = step_with_index
             # Use the individual session_state copy for this step
             step_session_state = session_state_copies[idx]
-            
+
             try:
                 inner_step_result = await step.aexecute(
                     step_input,
@@ -514,7 +577,12 @@ class Parallel:
                     user_id=user_id,
                     workflow_run_response=workflow_run_response,
                     store_executor_outputs=store_executor_outputs,
+                    workflow_session=workflow_session,
+                    add_workflow_history_to_steps=add_workflow_history_to_steps,
+                    num_history_runs=num_history_runs,
                     session_state=step_session_state,
+                    run_context=run_context,
+                    background_tasks=background_tasks,
                 )  # type: ignore[union-attr]
                 return idx, inner_step_result, step_session_state
             except Exception as exc:
@@ -568,7 +636,7 @@ class Parallel:
                 log_debug(f"Parallel step {step_name} completed")
 
         # Smart merge all session_state changes back into the original session_state
-        if session_state is not None:
+        if run_context is None and session_state is not None:
             merge_parallel_session_states(session_state, modified_session_states)
 
         # Sort by original index to preserve order
@@ -596,12 +664,19 @@ class Parallel:
         step_input: StepInput,
         session_id: Optional[str] = None,
         user_id: Optional[str] = None,
+        stream_events: bool = False,
         stream_intermediate_steps: bool = False,
+        stream_executor_events: bool = True,
         workflow_run_response: Optional[WorkflowRunOutput] = None,
         step_index: Optional[Union[int, tuple]] = None,
         store_executor_outputs: bool = True,
+        run_context: Optional[RunContext] = None,
         session_state: Optional[Dict[str, Any]] = None,
         parent_step_id: Optional[str] = None,
+        workflow_session: Optional[WorkflowSession] = None,
+        add_workflow_history_to_steps: Optional[bool] = False,
+        num_history_runs: int = 3,
+        background_tasks: Optional[Any] = 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="=")
@@ -613,12 +688,25 @@ class Parallel:
         # Create individual session_state copies for each step to prevent race conditions
         session_state_copies = []
         for _ in range(len(self.steps)):
-            if session_state is not None:
-                session_state_copies.append(deepcopy(session_state))
+            # If using run context, no need to deepcopy the state. We want the direct reference.
+            if run_context is not None and run_context.session_state is not None:
+                session_state_copies.append(run_context.session_state)
             else:
-                session_state_copies.append({})
+                if session_state is not None:
+                    session_state_copies.append(deepcopy(session_state))
+                else:
+                    session_state_copies.append({})
+
+        # Considering both stream_events and stream_intermediate_steps (deprecated)
+        if stream_intermediate_steps is not None:
+            warnings.warn(
+                "The 'stream_intermediate_steps' parameter is deprecated and will be removed in future versions. Use 'stream_events' instead.",
+                DeprecationWarning,
+                stacklevel=2,
+            )
+        stream_events = stream_events or stream_intermediate_steps
 
-        if stream_intermediate_steps and workflow_run_response:
+        if stream_events and workflow_run_response:
             # Yield parallel step started event
             yield ParallelExecutionStartedEvent(
                 run_id=workflow_run_response.run_id or "",
@@ -632,14 +720,20 @@ class Parallel:
                 parent_step_id=parent_step_id,
             )
 
+        import asyncio
+
+        event_queue = asyncio.Queue()  # type: ignore
+        step_results = []
+        modified_session_states = []
+
         async def execute_step_stream_async_with_index(step_with_index):
-            """Execute a single step with async streaming and preserve its original index"""
+            """Execute a single step with async streaming and yield events immediately"""
             idx, step = step_with_index
             # Use the individual session_state copy for this step
             step_session_state = session_state_copies[idx]
-            
+
             try:
-                step_events = []
+                step_outputs = []
 
                 # 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
@@ -655,83 +749,77 @@ class Parallel:
                     step_input,
                     session_id=session_id,
                     user_id=user_id,
-                    stream_intermediate_steps=stream_intermediate_steps,
+                    stream_events=stream_events,
+                    stream_executor_events=stream_executor_events,
                     workflow_run_response=workflow_run_response,
                     step_index=sub_step_index,
                     store_executor_outputs=store_executor_outputs,
                     session_state=step_session_state,
+                    run_context=run_context,
                     parent_step_id=parallel_step_id,
+                    workflow_session=workflow_session,
+                    add_workflow_history_to_steps=add_workflow_history_to_steps,
+                    num_history_runs=num_history_runs,
+                    background_tasks=background_tasks,
                 ):  # type: ignore[union-attr]
-                    step_events.append(event)
-                return idx, step_events, step_session_state
+                    # Yield events immediately to the queue
+                    await event_queue.put(("event", idx, event))
+                    if isinstance(event, StepOutput):
+                        step_outputs.append(event)
+
+                # Signal completion for this step
+                await event_queue.put(("complete", idx, step_outputs, step_session_state))
+                return idx, step_outputs, step_session_state
             except Exception as e:
                 parallel_step_name = getattr(step, "name", f"step_{idx}")
                 logger.error(f"Parallel step {parallel_step_name} async streaming failed: {e}")
-                return (
-                    idx,
-                    [
-                        StepOutput(
-                            step_name=parallel_step_name,
-                            content=f"Step {parallel_step_name} failed: {str(e)}",
-                            success=False,
-                            error=str(e),
-                        )
-                    ],
-                    step_session_state,
+                error_event = StepOutput(
+                    step_name=parallel_step_name,
+                    content=f"Step {parallel_step_name} failed: {str(e)}",
+                    success=False,
+                    error=str(e),
                 )
+                await event_queue.put(("event", idx, error_event))
+                await event_queue.put(("complete", idx, [error_event], step_session_state))
+                return idx, [error_event], step_session_state
 
-        # Use index to preserve order
+        # Start all parallel tasks
         indexed_steps = list(enumerate(self.steps))
-        all_events_with_indices = []
-        step_results = []
-        modified_session_states = []
+        tasks = [
+            asyncio.create_task(execute_step_stream_async_with_index(indexed_step)) for indexed_step in indexed_steps
+        ]
 
-        # Create tasks for all steps with their indices
-        tasks = [execute_step_stream_async_with_index(indexed_step) for indexed_step in indexed_steps]
+        # Process events as they arrive and track completion
+        completed_steps = 0
+        total_steps = len(self.steps)
 
-        # Execute all tasks concurrently
-        results_with_indices = await asyncio.gather(*tasks, return_exceptions=True)
+        while completed_steps < total_steps:
+            try:
+                message_type, step_idx, *data = await event_queue.get()
 
-        # Process results and handle exceptions, preserving order
-        for i, result in enumerate(results_with_indices):
-            if isinstance(result, Exception):
-                step_name = getattr(self.steps[i], "name", f"step_{i}")
-                logger.error(f"Parallel step {step_name} async streaming failed: {result}")
-                error_event = StepOutput(
-                    step_name=step_name,
-                    content=f"Step {step_name} failed: {str(result)}",
-                    success=False,
-                    error=str(result),
-                )
-                all_events_with_indices.append((i, [error_event]))
-                step_results.append(error_event)
-                modified_session_states.append(session_state_copies[i])
-            else:
-                index, events, modified_session_state = result  # type: ignore[misc]
-                all_events_with_indices.append((index, events))
-                modified_session_states.append(modified_session_state)
+                if message_type == "event":
+                    event = data[0]
+                    if not isinstance(event, StepOutput):
+                        yield event
 
-                # Extract StepOutput from events for the final result
-                step_outputs = [event for event in events if isinstance(event, StepOutput)]
-                if step_outputs:
+                elif message_type == "complete":
+                    step_outputs, step_session_state = data
                     step_results.extend(step_outputs)
+                    modified_session_states.append(step_session_state)
+                    completed_steps += 1
 
-                step_name = getattr(self.steps[index], "name", f"step_{index}")
-                log_debug(f"Parallel step {step_name} async streaming completed")
+                    step_name = getattr(self.steps[step_idx], "name", f"step_{step_idx}")
+                    log_debug(f"Parallel step {step_name} async streaming completed")
 
-        # Merge all session_state changes back into the original session_state
-        if session_state is not None:
-            merge_parallel_session_states(session_state, modified_session_states)
+            except Exception as e:
+                logger.error(f"Error processing parallel step events: {e}")
+                completed_steps += 1
 
-        # Sort events by original index to preserve order
-        all_events_with_indices.sort(key=lambda x: x[0])
+        await asyncio.gather(*tasks, return_exceptions=True)
 
-        # Yield all collected streaming events in order (but not final StepOutputs)
-        for _, events in all_events_with_indices:
-            for event in events:
-                # Only yield non-StepOutput events during streaming to avoid duplication
-                if not isinstance(event, StepOutput):
-                    yield event
+        # Merge all session_state changes back into the original session_state
+        if run_context is None and session_state is not None:
+            merge_parallel_session_states(session_state, modified_session_states)
 
         # Flatten step_results - handle steps that return List[StepOutput] (like Condition/Loop)
         flattened_step_results: List[StepOutput] = []
@@ -749,7 +837,7 @@ class Parallel:
 
         log_debug(f"Parallel End: {self.name} ({len(self.steps)} steps)", center=True, symbol="=")
 
-        if stream_intermediate_steps and workflow_run_response:
+        if stream_events and workflow_run_response:
             # Yield parallel step completed event
             yield ParallelExecutionCompletedEvent(
                 run_id=workflow_run_response.run_id or "",
@@ -759,7 +847,7 @@ class Parallel:
                 step_name=self.name,
                 step_index=step_index,
                 parallel_step_count=len(self.steps),
-                step_results=[aggregated_result],  # Now single aggregated result
+                step_results=flattened_step_results,
                 step_id=parallel_step_id,
                 parent_step_id=parent_step_id,
             )