agno 2.1.3__py3-none-any.whl → 2.1.4__py3-none-any.whl

agno/workflow/loop.py

@@ -13,6 +13,7 @@ from agno.run.workflow import (
     WorkflowRunOutput,
     WorkflowRunOutputEvent,
 )
+from agno.session.workflow import WorkflowSession
 from agno.utils.log import log_debug, logger
 from agno.workflow.step import Step
 from agno.workflow.types import StepInput, StepOutput, StepType
@@ -132,6 +133,9 @@ class Loop:
         workflow_run_response: Optional[WorkflowRunOutput] = None,
         store_executor_outputs: bool = True,
         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,
     ) -> StepOutput:
         """Execute loop steps with iteration control - mirrors workflow execution logic"""
         # Use workflow logger for loop orchestration
@@ -157,6 +161,9 @@ class Loop:
                     workflow_run_response=workflow_run_response,
                     store_executor_outputs=store_executor_outputs,
                     session_state=session_state,
+                    workflow_session=workflow_session,
+                    add_workflow_history_to_steps=add_workflow_history_to_steps,
+                    num_history_runs=num_history_runs,
                 )
 
                 # Handle both single StepOutput and List[StepOutput] (from Loop/Condition steps)
@@ -225,6 +232,9 @@ class Loop:
         store_executor_outputs: bool = True,
         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,
     ) -> Iterator[Union[WorkflowRunOutputEvent, StepOutput]]:
         """Execute loop steps with streaming support - mirrors workflow execution logic"""
         log_debug(f"Loop Start: {self.name}", center=True, symbol="=")
@@ -297,6 +307,9 @@ class Loop:
                     store_executor_outputs=store_executor_outputs,
                     session_state=session_state,
                     parent_step_id=loop_step_id,
+                    add_workflow_history_to_steps=add_workflow_history_to_steps,
+                    workflow_session=workflow_session,
+                    num_history_runs=num_history_runs,
                 ):
                     if isinstance(event, StepOutput):
                         step_outputs_for_iteration.append(event)
@@ -410,6 +423,9 @@ class Loop:
         workflow_run_response: Optional[WorkflowRunOutput] = None,
         store_executor_outputs: bool = True,
         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,
     ) -> StepOutput:
         """Execute loop steps asynchronously with iteration control - mirrors workflow execution logic"""
         # Use workflow logger for async loop orchestration
@@ -437,6 +453,9 @@ class Loop:
                     workflow_run_response=workflow_run_response,
                     store_executor_outputs=store_executor_outputs,
                     session_state=session_state,
+                    workflow_session=workflow_session,
+                    add_workflow_history_to_steps=add_workflow_history_to_steps,
+                    num_history_runs=num_history_runs,
                 )
 
                 # Handle both single StepOutput and List[StepOutput] (from Loop/Condition steps)
@@ -508,6 +527,9 @@ class Loop:
         store_executor_outputs: bool = True,
         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,
     ) -> 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="=")
@@ -580,6 +602,9 @@ class Loop:
                     store_executor_outputs=store_executor_outputs,
                     session_state=session_state,
                     parent_step_id=loop_step_id,
+                    workflow_session=workflow_session,
+                    add_workflow_history_to_steps=add_workflow_history_to_steps,
+                    num_history_runs=num_history_runs,
                 ):
                     if isinstance(event, StepOutput):
                         step_outputs_for_iteration.append(event)

agno/workflow/parallel.py

@@ -14,6 +14,7 @@ from agno.run.workflow import (
     WorkflowRunOutput,
     WorkflowRunOutputEvent,
 )
+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
@@ -200,6 +201,9 @@ class Parallel:
         workflow_run_response: Optional[WorkflowRunOutput] = None,
         store_executor_outputs: bool = True,
         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,
     ) -> StepOutput:
         """Execute all steps in parallel and return aggregated result"""
         # Use workflow logger for parallel orchestration
@@ -228,6 +232,9 @@ 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,
                 )  # type: ignore[union-attr]
                 return idx, step_result, step_session_state
@@ -315,6 +322,9 @@ class Parallel:
         store_executor_outputs: bool = True,
         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,
     ) -> 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="=")
@@ -345,14 +355,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
@@ -374,79 +390,81 @@ class Parallel:
                     store_executor_outputs=store_executor_outputs,
                     session_state=step_session_state,
                     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,
                 ):
-                    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]
-                for indexed_step in indexed_steps
-            }
+            # Submit all tasks
+            futures = [executor.submit(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:
             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:
@@ -473,7 +491,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,
             )
@@ -486,6 +504,9 @@ class Parallel:
         workflow_run_response: Optional[WorkflowRunOutput] = None,
         store_executor_outputs: bool = True,
         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,
     ) -> StepOutput:
         """Execute all steps in parallel using asyncio and return aggregated result"""
         # Use workflow logger for async parallel orchestration
@@ -514,6 +535,9 @@ 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,
                 )  # type: ignore[union-attr]
                 return idx, inner_step_result, step_session_state
@@ -602,6 +626,9 @@ class Parallel:
         store_executor_outputs: bool = True,
         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,
     ) -> 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="=")
@@ -632,14 +659,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
@@ -661,78 +694,69 @@ class Parallel:
                     store_executor_outputs=store_executor_outputs,
                     session_state=step_session_state,
                     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,
                 ):  # 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")
+
+            except Exception as e:
+                logger.error(f"Error processing parallel step events: {e}")
+                completed_steps += 1
+
+        await asyncio.gather(*tasks, return_exceptions=True)
 
         # 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)
 
-        # 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:
@@ -759,7 +783,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,
             )

agno/workflow/router.py

@@ -11,6 +11,7 @@ from agno.run.workflow import (
     WorkflowRunOutput,
     WorkflowRunOutputEvent,
 )
+from agno.session.workflow import WorkflowSession
 from agno.utils.log import log_debug, logger
 from agno.workflow.step import Step
 from agno.workflow.types import StepInput, StepOutput, StepType
@@ -150,6 +151,9 @@ class Router:
         workflow_run_response: Optional[WorkflowRunOutput] = None,
         session_state: Optional[Dict[str, Any]] = None,
         store_executor_outputs: bool = True,
+        workflow_session: Optional[WorkflowSession] = None,
+        add_workflow_history_to_steps: Optional[bool] = False,
+        num_history_runs: int = 3,
     ) -> StepOutput:
         """Execute the router and its selected steps with sequential chaining"""
         log_debug(f"Router Start: {self.name}", center=True, symbol="-")
@@ -184,6 +188,9 @@ class Router:
                     workflow_run_response=workflow_run_response,
                     store_executor_outputs=store_executor_outputs,
                     session_state=session_state,
+                    workflow_session=workflow_session,
+                    add_workflow_history_to_steps=add_workflow_history_to_steps,
+                    num_history_runs=num_history_runs,
                 )
 
                 # Handle both single StepOutput and List[StepOutput]
@@ -243,6 +250,9 @@ class Router:
         step_index: Optional[Union[int, tuple]] = None,
         store_executor_outputs: bool = True,
         parent_step_id: Optional[str] = None,
+        workflow_session: Optional[WorkflowSession] = None,
+        add_workflow_history_to_steps: Optional[bool] = False,
+        num_history_runs: int = 3,
     ) -> Iterator[Union[WorkflowRunOutputEvent, StepOutput]]:
         """Execute the router with streaming support"""
         log_debug(f"Router Start: {self.name}", center=True, symbol="-")
@@ -305,6 +315,9 @@ class Router:
                     store_executor_outputs=store_executor_outputs,
                     session_state=session_state,
                     parent_step_id=router_step_id,
+                    workflow_session=workflow_session,
+                    add_workflow_history_to_steps=add_workflow_history_to_steps,
+                    num_history_runs=num_history_runs,
                 ):
                     if isinstance(event, StepOutput):
                         step_outputs_for_step.append(event)
@@ -386,6 +399,9 @@ class Router:
         workflow_run_response: Optional[WorkflowRunOutput] = None,
         session_state: Optional[Dict[str, Any]] = None,
         store_executor_outputs: bool = True,
+        workflow_session: Optional[WorkflowSession] = None,
+        add_workflow_history_to_steps: Optional[bool] = False,
+        num_history_runs: int = 3,
     ) -> StepOutput:
         """Async execute the router and its selected steps with sequential chaining"""
         log_debug(f"Router Start: {self.name}", center=True, symbol="-")
@@ -421,6 +437,9 @@ class Router:
                     workflow_run_response=workflow_run_response,
                     store_executor_outputs=store_executor_outputs,
                     session_state=session_state,
+                    workflow_session=workflow_session,
+                    add_workflow_history_to_steps=add_workflow_history_to_steps,
+                    num_history_runs=num_history_runs,
                 )
                 # Handle both single StepOutput and List[StepOutput]
                 if isinstance(step_output, list):
@@ -482,6 +501,9 @@ class Router:
         step_index: Optional[Union[int, tuple]] = None,
         store_executor_outputs: bool = True,
         parent_step_id: Optional[str] = None,
+        workflow_session: Optional[WorkflowSession] = None,
+        add_workflow_history_to_steps: Optional[bool] = False,
+        num_history_runs: int = 3,
     ) -> AsyncIterator[Union[WorkflowRunOutputEvent, TeamRunOutputEvent, RunOutputEvent, StepOutput]]:
         """Async execute the router with streaming support"""
         log_debug(f"Router Start: {self.name}", center=True, symbol="-")
@@ -546,6 +568,9 @@ class Router:
                     store_executor_outputs=store_executor_outputs,
                     session_state=session_state,
                     parent_step_id=router_step_id,
+                    workflow_session=workflow_session,
+                    add_workflow_history_to_steps=add_workflow_history_to_steps,
+                    num_history_runs=num_history_runs,
                 ):
                     if isinstance(event, StepOutput):
                         step_outputs_for_step.append(event)