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

agno/workflow/step.py

@@ -17,6 +17,7 @@ from agno.run.workflow import (
     WorkflowRunOutput,
     WorkflowRunOutputEvent,
 )
+from agno.session.workflow import WorkflowSession
 from agno.team import Team
 from agno.utils.log import log_debug, logger, use_agent_logger, use_team_logger, use_workflow_logger
 from agno.utils.merge_dict import merge_dictionaries
@@ -60,6 +61,9 @@ class Step:
     # If False, only warn about missing inputs
     strict_input_validation: bool = False
 
+    add_workflow_history: Optional[bool] = None
+    num_history_runs: int = 3
+
     _retry_count: int = 0
 
     def __init__(
@@ -74,6 +78,8 @@ class Step:
         timeout_seconds: Optional[int] = None,
         skip_on_failure: bool = False,
         strict_input_validation: bool = False,
+        add_workflow_history: Optional[bool] = None,
+        num_history_runs: int = 3,
     ):
         # Auto-detect name for function executors if not provided
         if name is None and executor is not None:
@@ -93,6 +99,8 @@ class Step:
         self.timeout_seconds = timeout_seconds
         self.skip_on_failure = skip_on_failure
         self.strict_input_validation = strict_input_validation
+        self.add_workflow_history = add_workflow_history
+        self.num_history_runs = num_history_runs
         self.step_id = step_id
 
         if step_id is None:
@@ -204,6 +212,9 @@ class Step:
         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 step with StepInput, returning final StepOutput (non-streaming)"""
         log_debug(f"Executing step: {self.name}")
@@ -211,6 +222,8 @@ class Step:
         if step_input.previous_step_outputs:
             step_input.previous_step_content = step_input.get_last_step_content()
 
+        if workflow_session:
+            step_input.workflow_session = workflow_session
         session_state_copy = copy(session_state) if session_state is not None else {}
 
         # Execute with retries
@@ -292,8 +305,22 @@ class Step:
                         if isinstance(self.active_executor, Team):
                             kwargs["store_member_responses"] = True
 
+                        num_history_runs = self.num_history_runs if self.num_history_runs else num_history_runs
+
+                        use_history = (
+                            self.add_workflow_history
+                            if self.add_workflow_history is not None
+                            else add_workflow_history_to_steps
+                        )
+
+                        final_message = message
+                        if use_history and workflow_session:
+                            history_messages = workflow_session.get_workflow_history_context(num_runs=num_history_runs)
+                            if history_messages:
+                                final_message = f"{history_messages}{message}"
+
                         response = self.active_executor.run(  # type: ignore
-                            input=message,  # type: ignore
+                            input=final_message,  # type: ignore
                             images=images,
                             videos=videos,
                             audio=audios,
@@ -348,23 +375,55 @@ class Step:
         except Exception:
             return False
 
+    def _enrich_event_with_context(
+        self,
+        event: Any,
+        workflow_run_response: Optional["WorkflowRunOutput"] = None,
+        step_index: Optional[Union[int, tuple]] = None,
+    ) -> Any:
+        """Enrich event with step and workflow context information"""
+        if workflow_run_response is None:
+            return event
+
+        if hasattr(event, "workflow_id"):
+            event.workflow_id = workflow_run_response.workflow_id
+        if hasattr(event, "workflow_run_id"):
+            event.workflow_run_id = workflow_run_response.run_id
+        if hasattr(event, "step_id"):
+            event.step_id = self.step_id
+        if hasattr(event, "step_name") and self.name is not None:
+            if getattr(event, "step_name", None) is None:
+                event.step_name = self.name
+        # Only set step_index if it's not already set (preserve parallel.py's tuples)
+        if hasattr(event, "step_index") and step_index is not None:
+            if event.step_index is None:
+                event.step_index = step_index
+
+        return event
+
     def execute_stream(
         self,
         step_input: StepInput,
         session_id: Optional[str] = None,
         user_id: Optional[str] = None,
         stream_intermediate_steps: bool = False,
+        stream_executor_events: bool = True,
         workflow_run_response: Optional["WorkflowRunOutput"] = None,
         session_state: Optional[Dict[str, Any]] = None,
         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 step with event-driven streaming support"""
 
         if step_input.previous_step_outputs:
             step_input.previous_step_content = step_input.get_last_step_content()
 
+        if workflow_session:
+            step_input.workflow_session = workflow_session
         # Create session_state copy once to avoid duplication
         session_state_copy = copy(session_state) if session_state is not None else {}
 
@@ -413,7 +472,13 @@ class Step:
                                     final_response = event
                                     break
                                 else:
-                                    yield event  # type: ignore[misc]
+                                    # Enrich event with workflow context before yielding
+                                    enriched_event = self._enrich_event_with_context(
+                                        event, workflow_run_response, step_index
+                                    )
+                                    # Only yield executor events if stream_executor_events is True
+                                    if stream_executor_events:
+                                        yield enriched_event  # type: ignore[misc]
 
                             # Merge session_state changes back
                             if session_state is not None:
@@ -463,8 +528,22 @@ class Step:
                         if isinstance(self.active_executor, Team):
                             kwargs["store_member_responses"] = True
 
+                        num_history_runs = self.num_history_runs if self.num_history_runs else num_history_runs
+
+                        use_history = (
+                            self.add_workflow_history
+                            if self.add_workflow_history is not None
+                            else add_workflow_history_to_steps
+                        )
+
+                        final_message = message
+                        if use_history and workflow_session:
+                            history_messages = workflow_session.get_workflow_history_context(num_runs=num_history_runs)
+                            if history_messages:
+                                final_message = f"{history_messages}{message}"
+
                         response_stream = self.active_executor.run(  # type: ignore[call-overload, misc]
-                            input=message,
+                            input=final_message,
                             images=images,
                             videos=videos,
                             audio=audios,
@@ -474,14 +553,6 @@ class Step:
                             session_state=session_state_copy,  # Send a copy to the executor
                             stream=True,
                             stream_intermediate_steps=stream_intermediate_steps,
-                            # Pass workflow context directly via kwargs
-                            workflow_context={
-                                "workflow_id": workflow_run_response.workflow_id if workflow_run_response else None,
-                                "workflow_run_id": workflow_run_response.run_id if workflow_run_response else None,
-                                "step_id": self.step_id,
-                                "step_name": self.name,
-                                "step_index": step_index,
-                            },
                             yield_run_response=True,
                             **kwargs,
                         )
@@ -491,7 +562,10 @@ class Step:
                             if isinstance(event, RunOutput) or isinstance(event, TeamRunOutput):
                                 active_executor_run_response = event
                                 break
-                            yield event  # type: ignore[misc]
+                            enriched_event = self._enrich_event_with_context(event, workflow_run_response, step_index)
+                            # Only yield executor events if stream_executor_events is True
+                            if stream_executor_events:
+                                yield enriched_event  # type: ignore[misc]
 
                         if session_state is not None:
                             # Update workflow session state
@@ -558,6 +632,9 @@ class Step:
         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 step with StepInput, returning final StepOutput (non-streaming)"""
         logger.info(f"Executing async step (non-streaming): {self.name}")
@@ -566,6 +643,8 @@ class Step:
         if step_input.previous_step_outputs:
             step_input.previous_step_content = step_input.get_last_step_content()
 
+        if workflow_session:
+            step_input.workflow_session = workflow_session
         # Create session_state copy once to avoid duplication
         session_state_copy = copy(session_state) if session_state is not None else {}
 
@@ -670,8 +749,22 @@ class Step:
                         if isinstance(self.active_executor, Team):
                             kwargs["store_member_responses"] = True
 
+                        num_history_runs = self.num_history_runs if self.num_history_runs else num_history_runs
+
+                        use_history = (
+                            self.add_workflow_history
+                            if self.add_workflow_history is not None
+                            else add_workflow_history_to_steps
+                        )
+
+                        final_message = message
+                        if use_history and workflow_session:
+                            history_messages = workflow_session.get_workflow_history_context(num_runs=num_history_runs)
+                            if history_messages:
+                                final_message = f"{history_messages}{message}"
+
                         response = await self.active_executor.arun(  # type: ignore
-                            input=message,  # type: ignore
+                            input=final_message,  # type: ignore
                             images=images,
                             videos=videos,
                             audio=audios,
@@ -719,17 +812,24 @@ class Step:
         session_id: Optional[str] = None,
         user_id: Optional[str] = None,
         stream_intermediate_steps: bool = False,
+        stream_executor_events: bool = True,
         workflow_run_response: Optional["WorkflowRunOutput"] = None,
         session_state: Optional[Dict[str, Any]] = None,
         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, StepOutput]]:
         """Execute the step with event-driven streaming support"""
 
         if step_input.previous_step_outputs:
             step_input.previous_step_content = step_input.get_last_step_content()
 
+        if workflow_session:
+            step_input.workflow_session = workflow_session
+
         # Create session_state copy once to avoid duplication
         session_state_copy = copy(session_state) if session_state is not None else {}
 
@@ -776,7 +876,13 @@ class Step:
                                 final_response = event
                                 break
                             else:
-                                yield event  # type: ignore[misc]
+                                # Enrich event with workflow context before yielding
+                                enriched_event = self._enrich_event_with_context(
+                                    event, workflow_run_response, step_index
+                                )
+                                # Only yield executor events if stream_executor_events is True
+                                if stream_executor_events:
+                                    yield enriched_event  # type: ignore[misc]
                         if not final_response:
                             final_response = StepOutput(content=content)
                     elif inspect.iscoroutinefunction(self.active_executor):
@@ -803,7 +909,13 @@ class Step:
                                 final_response = event
                                 break
                             else:
-                                yield event  # type: ignore[misc]
+                                # Enrich event with workflow context before yielding
+                                enriched_event = self._enrich_event_with_context(
+                                    event, workflow_run_response, step_index
+                                )
+                                # Only yield executor events if stream_executor_events is True
+                                if stream_executor_events:
+                                    yield enriched_event  # type: ignore[misc]
                         if not final_response:
                             final_response = StepOutput(content=content)
                     else:
@@ -843,8 +955,22 @@ class Step:
                         if isinstance(self.active_executor, Team):
                             kwargs["store_member_responses"] = True
 
+                        num_history_runs = self.num_history_runs if self.num_history_runs else num_history_runs
+
+                        use_history = (
+                            self.add_workflow_history
+                            if self.add_workflow_history is not None
+                            else add_workflow_history_to_steps
+                        )
+
+                        final_message = message
+                        if use_history and workflow_session:
+                            history_messages = workflow_session.get_workflow_history_context(num_runs=num_history_runs)
+                            if history_messages:
+                                final_message = f"{history_messages}{message}"
+
                         response_stream = self.active_executor.arun(  # type: ignore
-                            input=message,
+                            input=final_message,
                             images=images,
                             videos=videos,
                             audio=audios,
@@ -854,14 +980,6 @@ class Step:
                             session_state=session_state_copy,
                             stream=True,
                             stream_intermediate_steps=stream_intermediate_steps,
-                            # Pass workflow context directly via kwargs
-                            workflow_context={
-                                "workflow_id": workflow_run_response.workflow_id if workflow_run_response else None,
-                                "workflow_run_id": workflow_run_response.run_id if workflow_run_response else None,
-                                "step_id": self.step_id,
-                                "step_name": self.name,
-                                "step_index": step_index,
-                            },
                             yield_run_response=True,
                             **kwargs,
                         )
@@ -871,7 +989,10 @@ class Step:
                             if isinstance(event, RunOutput) or isinstance(event, TeamRunOutput):
                                 active_executor_run_response = event
                                 break
-                            yield event  # type: ignore[misc]
+                            enriched_event = self._enrich_event_with_context(event, workflow_run_response, step_index)
+                            # Only yield executor events if stream_executor_events is True
+                            if stream_executor_events:
+                                yield enriched_event  # type: ignore[misc]
 
                         if session_state is not None:
                             # Update workflow session state

agno/workflow/steps.py

@@ -10,6 +10,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, StepInput, StepOutput, StepType
 
@@ -119,6 +120,9 @@ class Steps:
         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 all steps in sequence and return the final result"""
         log_debug(f"Steps Start: {self.name} ({len(self.steps)} steps)", center=True, symbol="-")
@@ -148,6 +152,9 @@ class Steps:
                     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/Router steps)
@@ -201,9 +208,13 @@ class Steps:
         session_id: Optional[str] = None,
         user_id: Optional[str] = None,
         stream_intermediate_steps: bool = False,
+        stream_executor_events: bool = True,
         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, TeamRunOutputEvent, RunOutputEvent, StepOutput]]:
         """Execute all steps in sequence with streaming support"""
         log_debug(f"Steps Start: {self.name} ({len(self.steps)} steps)", center=True, symbol="-")
@@ -256,10 +267,14 @@ class Steps:
                     user_id=user_id,
                     session_state=session_state,
                     stream_intermediate_steps=stream_intermediate_steps,
+                    stream_executor_events=stream_executor_events,
                     workflow_run_response=workflow_run_response,
                     step_index=child_step_index,
                     store_executor_outputs=store_executor_outputs,
                     parent_step_id=steps_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)
@@ -337,6 +352,9 @@ class Steps:
         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 all steps in sequence asynchronously and return the final result"""
         log_debug(f"Steps Start: {self.name} ({len(self.steps)} steps)", center=True, symbol="-")
@@ -366,6 +384,9 @@ class Steps:
                     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/Router steps)
@@ -418,9 +439,13 @@ class Steps:
         session_id: Optional[str] = None,
         user_id: Optional[str] = None,
         stream_intermediate_steps: bool = False,
+        stream_executor_events: bool = True,
         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]]:
         """Execute all steps in sequence with async streaming support"""
         log_debug(f"Steps Start: {self.name} ({len(self.steps)} steps)", center=True, symbol="-")
@@ -473,10 +498,14 @@ class Steps:
                     user_id=user_id,
                     session_state=session_state,
                     stream_intermediate_steps=stream_intermediate_steps,
+                    stream_executor_events=stream_executor_events,
                     workflow_run_response=workflow_run_response,
                     step_index=child_step_index,
                     store_executor_outputs=store_executor_outputs,
                     parent_step_id=steps_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)

agno/workflow/types.py

@@ -1,13 +1,14 @@
 import json
 from dataclasses import dataclass
 from enum import Enum
-from typing import Any, Dict, List, Optional, Union
+from typing import Any, Dict, List, Optional, Tuple, Union
 
 from fastapi import WebSocket
 from pydantic import BaseModel
 
 from agno.media import Audio, File, Image, Video
 from agno.models.metrics import Metrics
+from agno.session.workflow import WorkflowSession
 from agno.utils.log import log_warning
 from agno.utils.serialize import json_serializer
 
@@ -80,6 +81,8 @@ class StepInput:
     audio: Optional[List[Audio]] = None
     files: Optional[List[File]] = None
 
+    workflow_session: Optional["WorkflowSession"] = None
+
     def get_input_as_string(self) -> Optional[str]:
         """Convert input to string representation"""
         if self.input is None:
@@ -171,6 +174,28 @@ class StepInput:
         # Use the helper method to get the deepest content
         return self._get_deepest_step_content(last_output)  # type: ignore[return-value]
 
+    def get_workflow_history(self, num_runs: Optional[int] = None) -> List[Tuple[str, str]]:
+        """Get workflow conversation history as structured data for custom function steps
+
+        Args:
+            num_runs: Number of recent runs to include. If None, returns all available history.
+        """
+        if not self.workflow_session:
+            return []
+
+        return self.workflow_session.get_workflow_history(num_runs=num_runs)
+
+    def get_workflow_history_context(self, num_runs: Optional[int] = None) -> Optional[str]:
+        """Get formatted workflow conversation history context for custom function steps
+
+        Args:
+            num_runs: Number of recent runs to include. If None, returns all available history.
+        """
+        if not self.workflow_session:
+            return None
+
+        return self.workflow_session.get_workflow_history_context(num_runs=num_runs)
+
     def to_dict(self) -> Dict[str, Any]:
         """Convert to dictionary"""
         # Handle the unified message field