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

agno/workflow/workflow.py

@@ -1,807 +1,2512 @@
-from __future__ import annotations
-
-import collections.abc
-import inspect
-from dataclasses import dataclass, field, fields
+import asyncio
+from dataclasses import dataclass
+from datetime import datetime
 from os import getenv
-from types import GeneratorType
-from typing import Any, AsyncIterator, Callable, Dict, List, Optional, Union, cast, get_args
+from typing import (
+    Any,
+    AsyncIterator,
+    Awaitable,
+    Callable,
+    Dict,
+    Iterator,
+    List,
+    Literal,
+    Optional,
+    Tuple,
+    Type,
+    Union,
+    cast,
+    overload,
+)
 from uuid import uuid4
 
+from fastapi import WebSocket
 from pydantic import BaseModel
 
-from agno.agent import Agent
-from agno.media import AudioArtifact, ImageArtifact, VideoArtifact
-from agno.memory.v2.memory import Memory
-from agno.memory.workflow import WorkflowMemory, WorkflowRun
-from agno.run.response import RunResponse, RunResponseEvent
-from agno.run.team import TeamRunResponseEvent
-from agno.run.workflow import WorkflowRunResponseEvent
-from agno.storage.base import Storage
-from agno.storage.session.workflow import WorkflowSession
-from agno.utils.common import nested_model_dump
-from agno.utils.log import log_debug, log_warning, logger, set_log_level_to_debug, set_log_level_to_info
-from agno.utils.merge_dict import merge_dictionaries
-
-
-@dataclass(init=False)
+from agno.agent.agent import Agent
+from agno.db.base import BaseDb, SessionType
+from agno.exceptions import RunCancelledException
+from agno.media import Audio, AudioArtifact, File, Image, ImageArtifact, Video, VideoArtifact
+from agno.models.message import Message
+from agno.models.metrics import Metrics
+from agno.run.agent import RunEvent
+from agno.run.base import RunStatus
+from agno.run.cancel import (
+    cancel_run as cancel_run_global,
+)
+from agno.run.cancel import (
+    cleanup_run,
+    raise_if_cancelled,
+    register_run,
+)
+from agno.run.team import TeamRunEvent
+from agno.run.workflow import (
+    StepOutputEvent,
+    WorkflowCancelledEvent,
+    WorkflowCompletedEvent,
+    WorkflowRunEvent,
+    WorkflowRunOutput,
+    WorkflowRunOutputEvent,
+    WorkflowStartedEvent,
+)
+from agno.session.workflow import WorkflowSession
+from agno.team.team import Team
+from agno.utils.log import (
+    log_debug,
+    log_warning,
+    logger,
+    set_log_level_to_debug,
+    set_log_level_to_info,
+    use_workflow_logger,
+)
+from agno.utils.print_response.workflow import (
+    aprint_response,
+    aprint_response_stream,
+    print_response,
+    print_response_stream,
+)
+from agno.workflow.condition import Condition
+from agno.workflow.loop import Loop
+from agno.workflow.parallel import Parallel
+from agno.workflow.router import Router
+from agno.workflow.step import Step
+from agno.workflow.steps import Steps
+from agno.workflow.types import (
+    StepInput,
+    StepMetrics,
+    StepOutput,
+    StepType,
+    WebSocketHandler,
+    WorkflowExecutionInput,
+    WorkflowMetrics,
+)
+
+STEP_TYPE_MAPPING = {
+    Step: StepType.STEP,
+    Steps: StepType.STEPS,
+    Loop: StepType.LOOP,
+    Parallel: StepType.PARALLEL,
+    Condition: StepType.CONDITION,
+    Router: StepType.ROUTER,
+}
+
+WorkflowSteps = Union[
+    Callable[
+        ["Workflow", WorkflowExecutionInput],
+        Union[StepOutput, Awaitable[StepOutput], Iterator[StepOutput], AsyncIterator[StepOutput], Any],
+    ],
+    Steps,
+    List[
+        Union[
+            Callable[
+                [StepInput], Union[StepOutput, Awaitable[StepOutput], Iterator[StepOutput], AsyncIterator[StepOutput]]
+            ],
+            Step,
+            Steps,
+            Loop,
+            Parallel,
+            Condition,
+            Router,
+        ]
+    ],
+]
+
+
+@dataclass
 class Workflow:
-    # --- Workflow settings ---
-    # Workflow name
+    """Pipeline-based workflow execution"""
+
+    # Workflow identification - make name optional with default
     name: Optional[str] = None
-    # Workflow UUID (autogenerated if not set)
-    workflow_id: Optional[str] = None
-    # Workflow app_id (autogenerated if not set)
-    app_id: Optional[str] = None
-    # Workflow description (only shown in the UI)
+    # Workflow ID (autogenerated if not set)
+    id: Optional[str] = None
+    # Workflow description
     description: Optional[str] = None
 
-    # --- User settings ---
-    # ID of the user interacting with this workflow
-    user_id: Optional[str] = None
+    # Workflow steps
+    steps: Optional[WorkflowSteps] = None
 
-    # -*- Session settings
-    # Session UUID (autogenerated if not set)
+    # Database to use for this workflow
+    db: Optional[BaseDb] = None
+
+    # Default session_id to use for this workflow (autogenerated if not set)
     session_id: Optional[str] = None
-    # Session name
-    session_name: Optional[str] = None
-    # Session state stored in the database
-    session_state: Dict[str, Any] = field(default_factory=dict)
-
-    # --- Workflow Memory ---
-    memory: Optional[Union[WorkflowMemory, Memory]] = None
-
-    # --- Workflow Storage ---
-    storage: Optional[Storage] = None
-    # Extra data stored with this workflow
-    extra_data: Optional[Dict[str, Any]] = None
-
-    # --- Debug & Monitoring ---
-    # Enable debug logs
-    debug_mode: bool = False
-    # monitoring=True logs Workflow information to agno.com for monitoring
-    monitoring: bool = field(default_factory=lambda: getenv("AGNO_MONITOR", "false").lower() == "true")
+    # Default user_id to use for this workflow
+    user_id: Optional[str] = None
+    # Default session state (stored in the database to persist across runs)
+    session_state: Optional[Dict[str, Any]] = None
+
+    # If True, the workflow runs in debug mode
+    debug_mode: Optional[bool] = False
+
+    # --- Workflow Streaming ---
+    # Stream the response from the Workflow
+    stream: Optional[bool] = None
+    # Stream the intermediate steps from the Workflow
+    stream_intermediate_steps: bool = False
+
+    # Persist the events on the run response
+    store_events: bool = False
+    # Events to skip when persisting the events on the run response
+    events_to_skip: Optional[List[Union[WorkflowRunEvent, RunEvent, TeamRunEvent]]] = None
+
+    # Control whether to store executor responses (agent/team responses) in flattened runs
+    store_executor_outputs: bool = True
+
+    websocket_handler: Optional[WebSocketHandler] = None
+
+    # Input schema to validate the input to the workflow
+    input_schema: Optional[Type[BaseModel]] = None
+
+    # Metadata stored with this workflow
+    metadata: Optional[Dict[str, Any]] = None
+
+    # --- Telemetry ---
     # telemetry=True logs minimal telemetry for analytics
-    # This helps us improve the Workflow and provide better support
-    telemetry: bool = field(default_factory=lambda: getenv("AGNO_TELEMETRY", "true").lower() == "true")
-
-    # --- Run Info: DO NOT SET ---
-    run_id: Optional[str] = None
-    run_input: Optional[Dict[str, Any]] = None
-    run_response: Optional[RunResponse] = None
-    # Images generated during this session
-    images: Optional[List[ImageArtifact]] = None
-    # Videos generated during this session
-    videos: Optional[List[VideoArtifact]] = None
-    # Audio generated during this session
-    audio: Optional[List[AudioArtifact]] = None
+    # This helps us improve the Agent and provide better support
+    telemetry: bool = True
 
     def __init__(
         self,
-        *,
+        id: Optional[str] = None,
         name: Optional[str] = None,
-        workflow_id: Optional[str] = None,
         description: Optional[str] = None,
-        user_id: Optional[str] = None,
+        db: Optional[BaseDb] = None,
+        steps: Optional[WorkflowSteps] = None,
         session_id: Optional[str] = None,
-        session_name: Optional[str] = None,
         session_state: Optional[Dict[str, Any]] = None,
-        memory: Optional[Union[WorkflowMemory, Memory]] = None,
-        storage: Optional[Storage] = None,
-        extra_data: Optional[Dict[str, Any]] = None,
-        debug_mode: bool = False,
-        monitoring: bool = False,
+        user_id: Optional[str] = None,
+        debug_mode: Optional[bool] = False,
+        stream: Optional[bool] = None,
+        stream_intermediate_steps: bool = False,
+        store_events: bool = False,
+        events_to_skip: Optional[List[Union[WorkflowRunEvent, RunEvent, TeamRunEvent]]] = None,
+        store_executor_outputs: bool = True,
+        input_schema: Optional[Type[BaseModel]] = None,
+        metadata: Optional[Dict[str, Any]] = None,
+        cache_session: bool = False,
         telemetry: bool = True,
-        app_id: Optional[str] = None,
     ):
-        self.name = name or self.__class__.__name__
-        self.workflow_id = workflow_id
-        self.description = description or self.__class__.description
-        self.app_id = app_id
-
+        self.id = id
+        self.name = name
+        self.description = description
+        self.steps = steps
+        self.session_id = session_id
+        self.session_state = session_state
         self.user_id = user_id
+        self.debug_mode = debug_mode
+        self.store_events = store_events
+        self.events_to_skip = events_to_skip or []
+        self.stream = stream
+        self.stream_intermediate_steps = stream_intermediate_steps
+        self.store_executor_outputs = store_executor_outputs
+        self.input_schema = input_schema
+        self.metadata = metadata
+        self.cache_session = cache_session
+        self.db = db
+        self.telemetry = telemetry
 
-        self.session_id = session_id
-        self.session_name = session_name
-        self.session_state: Dict[str, Any] = session_state or {}
+        self._workflow_session: Optional[WorkflowSession] = None
 
-        self.memory = memory
-        self.storage = storage
-        self.extra_data = extra_data
+    def set_id(self) -> None:
+        if self.id is None:
+            if self.name is not None:
+                self.id = self.name.lower().replace(" ", "-")
+            else:
+                self.id = str(uuid4())
 
-        self.debug_mode = debug_mode
-        self.monitoring = monitoring
-        self.telemetry = telemetry
+    def _validate_input(
+        self, input: Optional[Union[str, Dict[str, Any], List[Any], BaseModel, List[Message]]]
+    ) -> Optional[BaseModel]:
+        """Parse and validate input against input_schema if provided"""
+        if self.input_schema is None:
+            return None
 
-        self.run_id = None
-        self.run_input = None
-        self.run_response = None
-        self.images = None
-        self.videos = None
-        self.audio = None
+        if input is None:
+            raise ValueError("Input required when input_schema is set")
 
-        self.workflow_session: Optional[WorkflowSession] = None
+        # Case 1: Message is already a BaseModel instance
+        if isinstance(input, BaseModel):
+            if isinstance(input, self.input_schema):
+                try:
+                    # Re-validate to catch any field validation errors
+                    input.model_validate(input.model_dump())
+                    return input
+                except Exception as e:
+                    raise ValueError(f"BaseModel validation failed: {str(e)}")
+            else:
+                # Different BaseModel types
+                raise ValueError(f"Expected {self.input_schema.__name__} but got {type(input).__name__}")
 
-        # Private attributes to store the run method and its parameters
-        # The run function provided by the subclass
-        self._subclass_run: Optional[Callable] = None
-        self._subclass_arun: Optional[Callable] = None
+        # Case 2: Message is a dict
+        elif isinstance(input, dict):
+            try:
+                validated_model = self.input_schema(**input)
+                return validated_model
+            except Exception as e:
+                raise ValueError(f"Failed to parse dict into {self.input_schema.__name__}: {str(e)}")
 
-        # Parameters of the run function
-        self._run_parameters: Optional[Dict[str, Any]] = None
-        # Return type of the run function
-        self._run_return_type: Optional[str] = None
+        # Case 3: Other types not supported for structured input
+        else:
+            raise ValueError(
+                f"Cannot validate {type(input)} against input_schema. Expected dict or {self.input_schema.__name__} instance."
+            )
 
-        self.update_run_method()
+    @property
+    def run_parameters(self) -> Dict[str, Any]:
+        """Get the run parameters for the workflow"""
+
+        if self.steps is None:
+            return {}
+
+        parameters = {}
+
+        if self.steps and callable(self.steps):
+            from inspect import Parameter, signature
+
+            sig = signature(self.steps)  # type: ignore
+
+            for param_name, param in sig.parameters.items():
+                if param_name not in ["workflow", "execution_input", "self"]:
+                    parameters[param_name] = {
+                        "name": param_name,
+                        "default": param.default.default
+                        if hasattr(param.default, "__class__") and param.default.__class__.__name__ == "FieldInfo"
+                        else (param.default if param.default is not Parameter.empty else None),
+                        "annotation": (
+                            param.annotation.__name__
+                            if hasattr(param.annotation, "__name__")
+                            else (
+                                str(param.annotation).replace("typing.Optional[", "").replace("]", "")
+                                if "typing.Optional" in str(param.annotation)
+                                else str(param.annotation)
+                            )
+                        )
+                        if param.annotation is not Parameter.empty
+                        else None,
+                        "required": param.default is Parameter.empty,
+                    }
+        else:
+            parameters = {
+                "message": {
+                    "name": "message",
+                    "default": None,
+                    "annotation": "str",
+                    "required": True,
+                },
+            }
 
-        self.__post_init__()
+        return parameters
 
-    def __post_init__(self):
-        for field_name, value in self.__class__.__dict__.items():
-            if isinstance(value, Agent):
-                value.session_id = self.session_id
+    def initialize_workflow(self):
+        if self.id is None:
+            self.set_id()
+            log_debug(f"Generated new workflow_id: {self.id}")
 
-    def run(self, **kwargs: Any):
-        logger.error(f"{self.__class__.__name__}.run() method not implemented.")
-        return
+    def _initialize_session(
+        self,
+        session_id: Optional[str] = None,
+        user_id: Optional[str] = None,
+        session_state: Optional[Dict[str, Any]] = None,
+        run_id: Optional[str] = None,
+    ) -> Tuple[str, Optional[str], Dict[str, Any]]:
+        """Initialize the session for the agent."""
 
-    def run_workflow(self, **kwargs: Any):
-        """Run the Workflow"""
+        if session_id is None:
+            if self.session_id:
+                session_id = self.session_id
+            else:
+                session_id = str(uuid4())
+                # We make the session_id sticky to the agent instance if no session_id is provided
+                self.session_id = session_id
+
+        log_debug(f"Session ID: {session_id}", center=True)
+
+        # Use the default user_id when necessary
+        if user_id is None:
+            user_id = self.user_id
+
+        # Determine the session_state
+        if session_state is None:
+            session_state = self.session_state or {}
+
+        if user_id is not None:
+            session_state["current_user_id"] = user_id
+        if session_id is not None:
+            session_state["current_session_id"] = session_id
+
+        session_state.update(
+            {
+                "workflow_id": self.id,
+                "run_id": run_id,
+                "session_id": session_id,
+            }
+        )
+        if self.name:
+            session_state["workflow_name"] = self.name
 
-        # Set mode, debug, workflow_id, session_id, initialize memory
-        self.set_storage_mode()
-        self.set_debug()
-        self.set_monitoring()
-        self.set_workflow_id()  # Ensure workflow_id is set
-        self.set_session_id()
-        self.initialize_memory()
+        return session_id, user_id, session_state  # type: ignore
 
-        # Create a run_id
-        self.run_id = str(uuid4())
+    def _generate_workflow_session_name(self) -> str:
+        """Generate a name for the workflow session"""
 
-        # Set run_input, run_response
-        self.run_input = kwargs
-        self.run_response = RunResponse(run_id=self.run_id, session_id=self.session_id, workflow_id=self.workflow_id)
+        if self.session_id is None:
+            return f"Workflow Session - {datetime.now().strftime('%Y-%m-%d %H:%M')}"
 
-        # Read existing session from storage
-        self.read_from_storage()
+        datetime_str = datetime.now().strftime("%Y-%m-%d %H:%M")
+        new_session_name = f"Workflow Session-{datetime_str}"
 
-        # Update the session_id for all Agent instances
-        self.update_agent_session_ids()
+        if self.description:
+            truncated_desc = self.description[:40] + "-" if len(self.description) > 40 else self.description
+            new_session_name = f"{truncated_desc} - {datetime_str}"
+        return new_session_name
 
-        log_debug(f"Workflow Run Start: {self.run_id}", center=True)
-        try:
-            self._subclass_run = cast(Callable, self._subclass_run)
-            result = self._subclass_run(**kwargs)
-        except Exception as e:
-            logger.error(f"Workflow.run() failed: {e}")
-            raise e
-
-        # The run_workflow() method handles both Iterator[RunResponse] and RunResponse
-        # Case 1: The run method returns an Iterator[RunResponse]
-        if isinstance(result, (GeneratorType, collections.abc.Iterator)):
-            # Initialize the run_response content
-            self.run_response.content = ""
-
-            def result_generator():
-                self.run_response = cast(RunResponse, self.run_response)
-                if isinstance(self.memory, WorkflowMemory):
-                    self.memory = cast(WorkflowMemory, self.memory)
-                elif isinstance(self.memory, Memory):
-                    self.memory = cast(Memory, self.memory)
-
-                for item in result:
-                    if (
-                        isinstance(item, tuple(get_args(RunResponseEvent)))
-                        or isinstance(item, tuple(get_args(TeamRunResponseEvent)))
-                        or isinstance(item, tuple(get_args(WorkflowRunResponseEvent)))
-                        or isinstance(item, RunResponse)
-                    ):
-                        # Update the run_id, session_id and workflow_id of the RunResponseEvent
-                        item.run_id = self.run_id
-                        item.session_id = self.session_id
-                        item.workflow_id = self.workflow_id
-
-                        # Update the run_response with the content from the result
-                        if hasattr(item, "content") and item.content is not None and isinstance(item.content, str):
-                            self.run_response.content += item.content
-                    else:
-                        logger.warning(f"Workflow.run() should only yield RunResponseEvent objects, got: {type(item)}")
-                    yield item
-
-                # Add the run to the memory
-                if isinstance(self.memory, WorkflowMemory):
-                    self.memory.add_run(WorkflowRun(input=self.run_input, response=self.run_response))
-                elif isinstance(self.memory, Memory):
-                    self.memory.add_run(session_id=self.session_id, run=self.run_response)  # type: ignore
-                # Write this run to the database
-                self.write_to_storage()
-                log_debug(f"Workflow Run End: {self.run_id}", center=True)
-
-            return result_generator()
-        # Case 2: The run method returns a RunResponse
-        elif isinstance(result, RunResponse):
-            # Update the result with the run_id, session_id and workflow_id of the workflow run
-            result.run_id = self.run_id
-            result.session_id = self.session_id
-            result.workflow_id = self.workflow_id
-
-            # Update the run_response with the content from the result
-            if result.content is not None and isinstance(result.content, str):
-                self.run_response.content = result.content
-
-            # Add the run to the memory
-            if isinstance(self.memory, WorkflowMemory):
-                self.memory.add_run(WorkflowRun(input=self.run_input, response=self.run_response))
-            elif isinstance(self.memory, Memory):
-                self.memory.add_run(session_id=self.session_id, run=self.run_response)  # type: ignore
-            # Write this run to the database
-            self.write_to_storage()
-            log_debug(f"Workflow Run End: {self.run_id}", center=True)
-            return result
+    def set_session_name(
+        self, session_id: Optional[str] = None, autogenerate: bool = False, session_name: Optional[str] = None
+    ) -> WorkflowSession:
+        """Set the session name and save to storage"""
+        session_id = session_id or self.session_id
+
+        if session_id is None:
+            raise Exception("Session ID is not set")
+
+        # -*- Read from storage
+        session = self.get_session(session_id=session_id)  # type: ignore
+
+        if autogenerate:
+            # -*- Generate name for session
+            session_name = self._generate_workflow_session_name()
+            log_debug(f"Generated Workflow Session Name: {session_name}")
+        elif session_name is None:
+            raise Exception("Session name is not set")
+
+        # -*- Rename session
+        session.session_data["session_name"] = session_name  # type: ignore
+
+        # -*- Save to storage
+        self.save_session(session=session)  # type: ignore
+
+        return session  # type: ignore
+
+    def get_session_name(self, session_id: Optional[str] = None) -> str:
+        """Get the session name for the given session ID and user ID."""
+        session_id = session_id or self.session_id
+        if session_id is None:
+            raise Exception("Session ID is not set")
+        session = self.get_session(session_id=session_id)  # type: ignore
+        if session is None:
+            raise Exception("Session not found")
+        return session.session_data.get("session_name", "") if session.session_data else ""
+
+    def get_session_state(self, session_id: Optional[str] = None) -> Dict[str, Any]:
+        """Get the session state for the given session ID and user ID."""
+        session_id = session_id or self.session_id
+        if session_id is None:
+            raise Exception("Session ID is not set")
+        session = self.get_session(session_id=session_id)  # type: ignore
+        if session is None:
+            raise Exception("Session not found")
+        return session.session_data.get("session_state", {}) if session.session_data else {}
+
+    def delete_session(self, session_id: str):
+        """Delete the current session and save to storage"""
+        if self.db is None:
+            return
+        # -*- Delete session
+        self.db.delete_session(session_id=session_id)
+
+    def get_run_output(self, run_id: str, session_id: Optional[str] = None) -> Optional[WorkflowRunOutput]:
+        """Get a RunOutput from the database."""
+        if self._workflow_session is not None:
+            run_response = self._workflow_session.get_run(run_id=run_id)
+            if run_response is not None:
+                return run_response
+            else:
+                log_warning(f"RunOutput {run_id} not found in AgentSession {self._workflow_session.session_id}")
+                return None
         else:
-            logger.warning(f"Workflow.run() should only return RunResponse objects, got: {type(result)}")
-            return None
+            workflow_session = self.get_session(session_id=session_id)
+            if workflow_session is not None:
+                run_response = workflow_session.get_run(run_id=run_id)
+                if run_response is not None:
+                    return run_response
+                else:
+                    log_warning(f"RunOutput {run_id} not found in AgentSession {session_id}")
+        return None
+
+    def get_last_run_output(self, session_id: Optional[str] = None) -> Optional[WorkflowRunOutput]:
+        """Get the last run response from the database."""
+        if (
+            self._workflow_session is not None
+            and self._workflow_session.runs is not None
+            and len(self._workflow_session.runs) > 0
+        ):
+            run_response = self._workflow_session.runs[-1]
+            if run_response is not None:
+                return run_response
+        else:
+            workflow_session = self.get_session(session_id=session_id)
+            if workflow_session is not None and workflow_session.runs is not None and len(workflow_session.runs) > 0:
+                run_response = workflow_session.runs[-1]
+                if run_response is not None:
+                    return run_response
+            else:
+                log_warning(f"No run responses found in WorkflowSession {session_id}")
+                return None
+
+    def read_or_create_session(
+        self,
+        session_id: str,
+        user_id: Optional[str] = None,
+    ) -> WorkflowSession:
+        from time import time
+
+        # Returning cached session if we have one
+        if self._workflow_session is not None and self._workflow_session.session_id == session_id:
+            return self._workflow_session
+
+        # Try to load from database
+        workflow_session = None
+        if self.db is not None:
+            log_debug(f"Reading WorkflowSession: {session_id}")
+
+            workflow_session = cast(WorkflowSession, self._read_session(session_id=session_id))
+
+        if workflow_session is None:
+            # Creating new session if none found
+            log_debug(f"Creating new WorkflowSession: {session_id}")
+            workflow_session = WorkflowSession(
+                session_id=session_id,
+                workflow_id=self.id,
+                user_id=user_id,
+                workflow_data=self._get_workflow_data(),
+                session_data={},
+                metadata=self.metadata,
+                created_at=int(time()),
+            )
+
+        # Cache the session if relevant
+        if workflow_session is not None and self.cache_session:
+            self._workflow_session = workflow_session
+
+        return workflow_session
+
+    def get_session(
+        self,
+        session_id: Optional[str] = None,
+    ) -> Optional[WorkflowSession]:
+        """Load an WorkflowSession from database.
 
-    # Add to workflow.py after the run_workflow method
-    async def arun_workflow(self, **kwargs: Any):
-        """Run the Workflow asynchronously"""
+        Args:
+            session_id: The session_id to load from storage.
 
-        # Set mode, debug, workflow_id, session_id, initialize memory
-        self.set_storage_mode()
-        self.set_debug()
-        self.set_monitoring()
-        self.set_workflow_id()  # Ensure workflow_id is set
-        self.set_session_id()
-        self.initialize_memory()
+        Returns:
+            WorkflowSession: The WorkflowSession loaded from the database or created if it does not exist.
+        """
+        if not session_id and not self.session_id:
+            raise Exception("No session_id provided")
 
-        # Create a run_id
-        self.run_id = str(uuid4())
+        session_id_to_load = session_id or self.session_id
 
-        # Set run_input, run_response
-        self.run_input = kwargs
-        self.run_response = RunResponse(run_id=self.run_id, session_id=self.session_id, workflow_id=self.workflow_id)
+        # Try to load from database
+        if self.db is not None and session_id_to_load is not None:
+            workflow_session = cast(WorkflowSession, self._read_session(session_id=session_id_to_load))
+            return workflow_session
 
-        # Read existing session from storage
-        self.read_from_storage()
+        log_warning(f"WorkflowSession {session_id_to_load} not found in db")
+        return None
 
-        # Update the session_id for all Agent instances
-        self.update_agent_session_ids()
+    def save_session(self, session: WorkflowSession) -> None:
+        """Save the WorkflowSession to storage
 
-        log_debug(f"Workflow Run Start: {self.run_id}", center=True)
+        Returns:
+            Optional[WorkflowSession]: The saved WorkflowSession or None if not saved.
+        """
+        if self.db is not None and session.session_data is not None:
+            if session.session_data.get("session_state") is not None:
+                session.session_data["session_state"].pop("current_session_id", None)
+                session.session_data["session_state"].pop("current_user_id", None)
+                session.session_data["session_state"].pop("current_run_id", None)
+                session.session_data["session_state"].pop("workflow_id", None)
+                session.session_data["session_state"].pop("run_id", None)
+                session.session_data["session_state"].pop("session_id", None)
+                session.session_data["session_state"].pop("workflow_name", None)
+
+            self._upsert_session(session=session)
+            log_debug(f"Created or updated WorkflowSession record: {session.session_id}")
+
+    # -*- Session Database Functions
+    def _read_session(self, session_id: str) -> Optional[WorkflowSession]:
+        """Get a Session from the database."""
         try:
-            self._subclass_arun = cast(Callable, self._subclass_arun)
-            result = await self._subclass_arun(**kwargs)
+            if not self.db:
+                raise ValueError("Db not initialized")
+            session = self.db.get_session(session_id=session_id, session_type=SessionType.WORKFLOW)
+            return session if isinstance(session, (WorkflowSession, type(None))) else None
         except Exception as e:
-            logger.error(f"Workflow.arun() failed: {e}")
-            raise e
-
-        # Handle single RunResponse result
-        if isinstance(result, RunResponse):
-            # Update the result with the run_id, session_id and workflow_id of the workflow run
-            result.run_id = self.run_id
-            result.session_id = self.session_id
-            result.workflow_id = self.workflow_id
-
-            # Update the run_response with the content from the result
-            if result.content is not None and isinstance(result.content, str):
-                self.run_response.content = result.content
-
-            # Add the run to the memory
-            if isinstance(self.memory, WorkflowMemory):
-                self.memory.add_run(WorkflowRun(input=self.run_input, response=self.run_response))
-            elif isinstance(self.memory, Memory):
-                self.memory.add_run(session_id=self.session_id, run=self.run_response)  # type: ignore
-            # Write this run to the database
-            self.write_to_storage()
-            log_debug(f"Workflow Run End: {self.run_id}", center=True)
-            return result
-        else:
-            logger.warning(f"Workflow.arun() should only return RunResponse objects, got: {type(result)}")
+            log_warning(f"Error getting session from db: {e}")
             return None
 
-    async def arun_workflow_generator(self, **kwargs: Any) -> AsyncIterator[RunResponse]:
-        """Run the Workflow asynchronously for async generators"""
+    def _upsert_session(self, session: WorkflowSession) -> Optional[WorkflowSession]:
+        """Upsert a Session into the database."""
 
-        # Set mode, debug, workflow_id, session_id, initialize memory
-        self.set_storage_mode()
-        self.set_debug()
-        self.set_monitoring()
-        self.set_workflow_id()  # Ensure workflow_id is set
-        self.set_session_id()
-        self.initialize_memory()
+        try:
+            if not self.db:
+                raise ValueError("Db not initialized")
+            result = self.db.upsert_session(session=session)
+            return result if isinstance(result, (WorkflowSession, type(None))) else None
+        except Exception as e:
+            log_warning(f"Error upserting session into db: {e}")
+            return None
 
-        # Create a run_id
-        self.run_id = str(uuid4())
+    def _update_metadata(self, session: WorkflowSession):
+        """Update the extra_data in the session"""
+        from agno.utils.merge_dict import merge_dictionaries
 
-        # Set run_input, run_response
-        self.run_input = kwargs
-        self.run_response = RunResponse(run_id=self.run_id, session_id=self.session_id, workflow_id=self.workflow_id)
+        # Read metadata from the database
+        if session.metadata is not None:
+            # If metadata is set in the workflow, update the database metadata with the workflow's metadata
+            if self.metadata is not None:
+                # Updates workflow's session metadata in place
+                merge_dictionaries(session.metadata, self.metadata)
+            # Update the current metadata with the metadata from the database which is updated in place
+            self.metadata = session.metadata
 
-        # Read existing session from storage
-        self.read_from_storage()
+    def _update_session_state(self, session: WorkflowSession, session_state: Dict[str, Any]):
+        """Load the existing Workflow from a WorkflowSession (from the database)"""
 
-        # Update the session_id for all Agent instances
-        self.update_agent_session_ids()
+        from agno.utils.merge_dict import merge_dictionaries
+
+        # Get the session_state from the database and update the current session_state
+        if session.session_data and "session_state" in session.session_data:
+            session_state_from_db = session.session_data.get("session_state")
+
+            if (
+                session_state_from_db is not None
+                and isinstance(session_state_from_db, dict)
+                and len(session_state_from_db) > 0
+            ):
+                # This updates session_state_from_db
+                # If there are conflicting keys, values from provided session_state will take precedence
+                merge_dictionaries(session_state_from_db, session_state)
+                session_state = session_state_from_db
+
+        # Update the session_state in the session
+        if session.session_data is None:
+            session.session_data = {}
+        session.session_data["session_state"] = session_state
+
+        return session_state
+
+    def _get_workflow_data(self) -> Dict[str, Any]:
+        workflow_data = {}
+
+        if self.steps and not callable(self.steps):
+            steps_dict = []
+            for step in self.steps:  # type: ignore
+                if callable(step):
+                    step_type = StepType.STEP
+                elif isinstance(step, Agent) or isinstance(step, Team):
+                    step_type = StepType.STEP
+                else:
+                    step_type = STEP_TYPE_MAPPING[type(step)]
+                step_dict = {
+                    "name": step.name if hasattr(step, "name") else step.__name__,
+                    "description": step.description if hasattr(step, "description") else "User-defined callable step",
+                    "type": step_type.value,
+                }
+                steps_dict.append(step_dict)
 
-        log_debug(f"Workflow Run Start: {self.run_id}", center=True)
-        # Initialize the run_response content
-        self.run_response.content = ""
-        try:
-            self._subclass_arun = cast(Callable, self._subclass_arun)
-            async for item in self._subclass_arun(**kwargs):
-                if (
-                    isinstance(item, tuple(get_args(RunResponseEvent)))
-                    or isinstance(item, tuple(get_args(TeamRunResponseEvent)))
-                    or isinstance(item, tuple(get_args(WorkflowRunResponseEvent)))
-                    or isinstance(item, RunResponse)
-                ):
-                    # Update the run_id, session_id and workflow_id of the RunResponseEvent
-                    item.run_id = self.run_id
-                    item.session_id = self.session_id
-                    item.workflow_id = self.workflow_id
+            workflow_data["steps"] = steps_dict
 
-                    # Update the run_response with the content from the result
-                    if hasattr(item, "content") and item.content is not None and isinstance(item.content, str):
-                        self.run_response.content += item.content
-                else:
-                    logger.warning(f"Workflow.run() should only yield RunResponseEvent objects, got: {type(item)}")
-                yield item
-
-            # Add the run to the memory
-            if isinstance(self.memory, WorkflowMemory):
-                self.memory.add_run(WorkflowRun(input=self.run_input, response=self.run_response))
-            elif isinstance(self.memory, Memory):
-                self.memory.add_run(session_id=self.session_id, run=self.run_response)  # type: ignore
-            # Write this run to the database
-            self.write_to_storage()
-            log_debug(f"Workflow Run End: {self.run_id}", center=True)
-        except Exception as e:
-            logger.error(f"Workflow.arun() failed: {e}")
-            raise e
+        elif callable(self.steps):
+            workflow_data["steps"] = [
+                {
+                    "name": "Custom Function",
+                    "description": "User-defined callable workflow",
+                    "type": "Callable",
+                }
+            ]
 
-    async def arun(self, **kwargs: Any):
-        """Async version of run() that calls arun_workflow()"""
-        logger.error(f"{self.__class__.__name__}.arun() method not implemented.")
-        return
+        return workflow_data
+
+    def _handle_event(
+        self,
+        event: "WorkflowRunOutputEvent",
+        workflow_run_response: WorkflowRunOutput,
+        websocket_handler: Optional[WebSocketHandler] = None,
+    ) -> "WorkflowRunOutputEvent":
+        """Handle workflow events for storage - similar to Team._handle_event"""
+        if self.store_events:
+            # Check if this event type should be skipped
+            if self.events_to_skip:
+                event_type = event.event
+                for skip_event in self.events_to_skip:
+                    if isinstance(skip_event, str):
+                        if event_type == skip_event:
+                            return event
+                    else:
+                        # It's a WorkflowRunEvent enum
+                        if event_type == skip_event.value:
+                            return event
 
-    def set_storage_mode(self):
-        if self.storage is not None:
-            self.storage.mode = "workflow"
+            # Store the event
+            if workflow_run_response.events is None:
+                workflow_run_response.events = []
 
-    def initialize_workflow(self):
-        self.set_storage_mode()
+            workflow_run_response.events.append(event)
 
-    def set_workflow_id(self) -> str:
-        if self.workflow_id is None:
-            self.workflow_id = str(uuid4())
-        log_debug(f"Workflow ID: {self.workflow_id}", center=True)
-        return self.workflow_id
+        # Broadcast to WebSocket if available (async context only)
+        if websocket_handler:
+            import asyncio
 
-    def set_session_id(self) -> str:
-        if self.session_id is None:
-            self.session_id = str(uuid4())
-        log_debug(f"Session ID: {self.session_id}", center=True)
-        return self.session_id
+            try:
+                loop = asyncio.get_running_loop()
+                if loop:
+                    asyncio.create_task(websocket_handler.handle_event(event))
+            except RuntimeError:
+                pass
+
+        return event
+
+    def _transform_step_output_to_event(
+        self, step_output: StepOutput, workflow_run_response: WorkflowRunOutput, step_index: Optional[int] = None
+    ) -> StepOutputEvent:
+        """Transform a StepOutput object into a StepOutputEvent for consistent streaming interface"""
+        return StepOutputEvent(
+            step_output=step_output,
+            run_id=workflow_run_response.run_id or "",
+            workflow_name=workflow_run_response.workflow_name,
+            workflow_id=workflow_run_response.workflow_id,
+            session_id=workflow_run_response.session_id,
+            step_name=step_output.step_name,
+            step_index=step_index,
+        )
 
-    def set_debug(self) -> None:
+    def _set_debug(self) -> None:
+        """Set debug mode and configure logging"""
         if self.debug_mode or getenv("AGNO_DEBUG", "false").lower() == "true":
+            use_workflow_logger()
+
             self.debug_mode = True
-            set_log_level_to_debug()
-            log_debug("Debug logs enabled")
-        else:
-            set_log_level_to_info()
+            set_log_level_to_debug(source_type="workflow")
+
+            # Propagate to steps - only if steps is iterable (not callable)
+            if self.steps and not callable(self.steps):
+                if isinstance(self.steps, Steps):
+                    steps_to_iterate = self.steps.steps
+                else:
+                    steps_to_iterate = self.steps
 
-    def set_monitoring(self) -> None:
-        """Override monitoring and telemetry settings based on environment variables."""
+                for step in steps_to_iterate:
+                    self._propagate_debug_to_step(step)
+        else:
+            set_log_level_to_info(source_type="workflow")
 
-        # Only override if the environment variable is set
-        monitor_env = getenv("AGNO_MONITOR")
-        if monitor_env is not None:
-            self.monitoring = monitor_env.lower() == "true"
+    def _set_telemetry(self) -> None:
+        """Override telemetry settings based on environment variables."""
 
-        # Override telemetry if environment variable is set
         telemetry_env = getenv("AGNO_TELEMETRY")
         if telemetry_env is not None:
             self.telemetry = telemetry_env.lower() == "true"
 
-    def initialize_memory(self) -> None:
-        if self.memory is None:
-            self.memory = Memory()
-
-    def update_run_method(self):
-        run_type = None
-        # Update the run() method to call run_workflow() instead of the subclass's run()
-        # First, check if the subclass has a run method
-        #   If the run() method has been overridden by the subclass,
-        #   then self.__class__.run is not Workflow.run will be True
-        if self.__class__.run is not Workflow.run:
-            # Store the original run methods bound to the instance
-            self._subclass_run = self.__class__.run.__get__(self)
-            run_type = "sync"
-            # Get the parameters of the sync run method
-            sig = inspect.signature(self.__class__.run)
-
-        if self.__class__.arun is not Workflow.arun:
-            self._subclass_arun = self.__class__.arun.__get__(self)
-            run_type = "coroutine"
-
-            # Get the parameters of the async run method
-            sig = inspect.signature(self.__class__.arun)
-
-            # Check if the async method is a coroutine or async generator
-            from inspect import isasyncgenfunction
-
-            if isasyncgenfunction(self.__class__.arun):
-                run_type = "async_generator"
-
-        if run_type is not None:
-            # Convert parameters to a serializable format
-            self._run_parameters = {
-                param_name: {
-                    "name": param_name,
-                    "default": param.default.default
-                    if hasattr(param.default, "__class__") and param.default.__class__.__name__ == "FieldInfo"
-                    else (param.default if param.default is not inspect.Parameter.empty else None),
-                    "annotation": (
-                        param.annotation.__name__
-                        if hasattr(param.annotation, "__name__")
-                        else (
-                            str(param.annotation).replace("typing.Optional[", "").replace("]", "")
-                            if "typing.Optional" in str(param.annotation)
-                            else str(param.annotation)
-                        )
+    def _propagate_debug_to_step(self, step):
+        """Recursively propagate debug mode to steps and nested primitives"""
+        # Handle direct Step objects
+        if hasattr(step, "active_executor") and step.active_executor:
+            executor = step.active_executor
+            if hasattr(executor, "debug_mode"):
+                executor.debug_mode = True
+
+            # If it's a team, propagate to all members
+            if hasattr(executor, "members"):
+                for member in executor.members:
+                    if hasattr(member, "debug_mode"):
+                        member.debug_mode = True
+
+        # Handle nested primitives - check both 'steps' and 'choices' attributes
+        for attr_name in ["steps", "choices"]:
+            if hasattr(step, attr_name):
+                attr_value = getattr(step, attr_name)
+                if attr_value and isinstance(attr_value, list):
+                    for nested_step in attr_value:
+                        self._propagate_debug_to_step(nested_step)
+
+    def _create_step_input(
+        self,
+        execution_input: WorkflowExecutionInput,
+        previous_step_outputs: Optional[Dict[str, StepOutput]] = None,
+        shared_images: Optional[List[ImageArtifact]] = None,
+        shared_videos: Optional[List[VideoArtifact]] = None,
+        shared_audio: Optional[List[AudioArtifact]] = None,
+        shared_files: Optional[List[File]] = None,
+    ) -> StepInput:
+        """Helper method to create StepInput with enhanced data flow support"""
+
+        previous_step_content = None
+        if previous_step_outputs:
+            last_output = list(previous_step_outputs.values())[-1]
+            previous_step_content = last_output.content if last_output else None
+            log_debug(f"Using previous step content from: {list(previous_step_outputs.keys())[-1]}")
+
+        return StepInput(
+            input=execution_input.input,
+            previous_step_content=previous_step_content,
+            previous_step_outputs=previous_step_outputs,
+            additional_data=execution_input.additional_data,
+            images=shared_images or [],
+            videos=shared_videos or [],
+            audio=shared_audio or [],
+            files=shared_files or [],
+        )
+
+    def _get_step_count(self) -> int:
+        """Get the number of steps in the workflow"""
+        if self.steps is None:
+            return 0
+        elif callable(self.steps):
+            return 1  # Callable function counts as 1 step
+        else:
+            # Handle Steps wrapper
+            if isinstance(self.steps, Steps):
+                return len(self.steps.steps)
+            else:
+                return len(self.steps)
+
+    def _aggregate_workflow_metrics(self, step_results: List[Union[StepOutput, List[StepOutput]]]) -> WorkflowMetrics:
+        """Aggregate metrics from all step responses into structured workflow metrics"""
+        steps_dict = {}
+
+        def process_step_output(step_output: StepOutput):
+            """Process a single step output for metrics"""
+
+            # If this step has nested steps, process them recursively
+            if hasattr(step_output, "steps") and step_output.steps:
+                for nested_step in step_output.steps:
+                    process_step_output(nested_step)
+
+            # Only collect metrics from steps that actually have metrics (actual agents/teams)
+            if (
+                step_output.step_name and step_output.metrics and step_output.executor_type in ["agent", "team"]
+            ):  # Only include actual executors
+                step_metrics = StepMetrics(
+                    step_name=step_output.step_name,
+                    executor_type=step_output.executor_type or "unknown",
+                    executor_name=step_output.executor_name or "unknown",
+                    metrics=step_output.metrics,
+                )
+                steps_dict[step_output.step_name] = step_metrics
+
+        # Process all step results
+        for step_result in step_results:
+            process_step_output(cast(StepOutput, step_result))
+
+        return WorkflowMetrics(
+            steps=steps_dict,
+        )
+
+    def _call_custom_function(self, func: Callable, execution_input: WorkflowExecutionInput, **kwargs: Any) -> Any:
+        """Call custom function with only the parameters it expects"""
+        from inspect import signature
+
+        sig = signature(func)
+
+        # Build arguments based on what the function actually accepts
+        call_kwargs: Dict[str, Any] = {}
+
+        # Only add workflow and execution_input if the function expects them
+        if "workflow" in sig.parameters:  # type: ignore
+            call_kwargs["workflow"] = self
+        if "execution_input" in sig.parameters:
+            call_kwargs["execution_input"] = execution_input  # type: ignore
+        if "session_state" in sig.parameters:
+            call_kwargs["session_state"] = self.session_state  # type: ignore
+
+        # Add any other kwargs that the function expects
+        for param_name in kwargs:
+            if param_name in sig.parameters:  # type: ignore
+                call_kwargs[param_name] = kwargs[param_name]
+
+        # If function has **kwargs parameter, pass all remaining kwargs
+        for param in sig.parameters.values():  # type: ignore
+            if param.kind == param.VAR_KEYWORD:
+                call_kwargs.update(kwargs)
+                break
+
+        try:
+            return func(**call_kwargs)
+        except TypeError as e:
+            # If signature inspection fails, fall back to original method
+            logger.warning(
+                f"Async function signature inspection failed: {e}. Falling back to original calling convention."
+            )
+            return func(**call_kwargs)
+
+    def _execute(
+        self,
+        session: WorkflowSession,
+        execution_input: WorkflowExecutionInput,
+        workflow_run_response: WorkflowRunOutput,
+        session_state: Optional[Dict[str, Any]] = None,
+        **kwargs: Any,
+    ) -> WorkflowRunOutput:
+        """Execute a specific pipeline by name synchronously"""
+        from inspect import isasyncgenfunction, iscoroutinefunction, isgeneratorfunction
+
+        workflow_run_response.status = RunStatus.running
+        register_run(workflow_run_response.run_id)  # type: ignore
+
+        if callable(self.steps):
+            if iscoroutinefunction(self.steps) or isasyncgenfunction(self.steps):
+                raise ValueError("Cannot use async function with synchronous execution")
+            elif isgeneratorfunction(self.steps):
+                content = ""
+                for chunk in self.steps(self, execution_input, **kwargs):
+                    # Check for cancellation while consuming generator
+                    raise_if_cancelled(workflow_run_response.run_id)  # type: ignore
+                    if hasattr(chunk, "content") and chunk.content is not None and isinstance(chunk.content, str):
+                        content += chunk.content
+                    else:
+                        content += str(chunk)
+                workflow_run_response.content = content
+            else:
+                # Execute the workflow with the custom executor
+                raise_if_cancelled(workflow_run_response.run_id)  # type: ignore
+                workflow_run_response.content = self._call_custom_function(self.steps, execution_input, **kwargs)  # type: ignore[arg-type]
+
+            workflow_run_response.status = RunStatus.completed
+        else:
+            try:
+                # Track outputs from each step for enhanced data flow
+                collected_step_outputs: List[Union[StepOutput, List[StepOutput]]] = []
+                previous_step_outputs: Dict[str, StepOutput] = {}
+
+                shared_images: List[ImageArtifact] = execution_input.images or []
+                output_images: List[ImageArtifact] = (execution_input.images or []).copy()  # Start with input images
+                shared_videos: List[VideoArtifact] = execution_input.videos or []
+                output_videos: List[VideoArtifact] = (execution_input.videos or []).copy()  # Start with input videos
+                shared_audio: List[AudioArtifact] = execution_input.audio or []
+                output_audio: List[AudioArtifact] = (execution_input.audio or []).copy()  # Start with input audio
+                shared_files: List[File] = execution_input.files or []
+                output_files: List[File] = (execution_input.files or []).copy()  # Start with input files
+
+                for i, step in enumerate(self.steps):  # type: ignore[arg-type]
+                    raise_if_cancelled(workflow_run_response.run_id)  # type: ignore
+                    step_name = getattr(step, "name", f"step_{i + 1}")
+                    log_debug(f"Executing step {i + 1}/{self._get_step_count()}: {step_name}")
+
+                    # Create enhanced StepInput
+                    step_input = self._create_step_input(
+                        execution_input=execution_input,
+                        previous_step_outputs=previous_step_outputs,
+                        shared_images=shared_images,
+                        shared_videos=shared_videos,
+                        shared_audio=shared_audio,
+                        shared_files=shared_files,
                     )
-                    if param.annotation is not inspect.Parameter.empty
-                    else None,
-                    "required": param.default is inspect.Parameter.empty,
-                }
-                for param_name, param in sig.parameters.items()
-                if param_name != "self"
-            }
-            # Determine the return type of the run method
-            return_annotation = sig.return_annotation
-            self._run_return_type = (
-                return_annotation.__name__
-                if return_annotation is not inspect.Signature.empty and hasattr(return_annotation, "__name__")
-                else str(return_annotation)
-                if return_annotation is not inspect.Signature.empty
-                else None
+
+                    # Check for can cellation before executing step
+                    raise_if_cancelled(workflow_run_response.run_id)  # type: ignore
+
+                    step_output = step.execute(  # type: ignore[union-attr]
+                        step_input,
+                        session_id=session.session_id,
+                        user_id=self.user_id,
+                        workflow_run_response=workflow_run_response,
+                        session_state=session_state,
+                        store_executor_outputs=self.store_executor_outputs,
+                    )
+
+                    # Check for cancellation after step execution
+                    raise_if_cancelled(workflow_run_response.run_id)  # type: ignore
+
+                    # Update the workflow-level previous_step_outputs dictionary
+                    previous_step_outputs[step_name] = step_output
+                    if step_output.stop:
+                        logger.info(f"Early termination requested by step {step_name}")
+                        break
+
+                    # Update shared media for next step
+                    shared_images.extend(step_output.images or [])
+                    shared_videos.extend(step_output.videos or [])
+                    shared_audio.extend(step_output.audio or [])
+                    shared_files.extend(step_output.files or [])
+                    output_images.extend(step_output.images or [])
+                    output_videos.extend(step_output.videos or [])
+                    output_audio.extend(step_output.audio or [])
+                    output_files.extend(step_output.files or [])
+
+                    collected_step_outputs.append(step_output)
+
+                # Update the workflow_run_response with completion data
+                if collected_step_outputs:
+                    workflow_run_response.metrics = self._aggregate_workflow_metrics(collected_step_outputs)
+                    last_output = cast(StepOutput, collected_step_outputs[-1])
+
+                    # Use deepest nested content if this is a container (Steps/Router/Loop/etc.)
+                    if getattr(last_output, "steps", None):
+                        _cur = last_output
+                        while getattr(_cur, "steps", None):
+                            _steps = _cur.steps or []
+                            if not _steps:
+                                break
+                            _cur = _steps[-1]
+                        workflow_run_response.content = _cur.content
+                    else:
+                        workflow_run_response.content = last_output.content
+                else:
+                    workflow_run_response.content = "No steps executed"
+
+                workflow_run_response.step_results = collected_step_outputs
+                workflow_run_response.images = output_images
+                workflow_run_response.videos = output_videos
+                workflow_run_response.audio = output_audio
+                workflow_run_response.status = RunStatus.completed
+
+            except RunCancelledException as e:
+                # Handle run cancellation
+                logger.info(f"Workflow run {workflow_run_response.run_id} was cancelled")
+                workflow_run_response.status = RunStatus.cancelled
+                workflow_run_response.content = str(e)
+            except Exception as e:
+                import traceback
+
+                traceback.print_exc()
+                logger.error(f"Workflow execution failed: {e}")
+                # Store error response
+                workflow_run_response.status = RunStatus.error
+                workflow_run_response.content = f"Workflow execution failed: {e}"
+
+            finally:
+                self._update_session_metrics(session=session, workflow_run_response=workflow_run_response)
+                session.upsert_run(run=workflow_run_response)
+                self.save_session(session=session)
+                # Always clean up the run tracking
+                cleanup_run(workflow_run_response.run_id)  # type: ignore
+
+        # Log Workflow Telemetry
+        if self.telemetry:
+            self._log_workflow_telemetry(session_id=session.session_id, run_id=workflow_run_response.run_id)
+
+        return workflow_run_response
+
+    def _execute_stream(
+        self,
+        session: WorkflowSession,
+        execution_input: WorkflowExecutionInput,
+        workflow_run_response: WorkflowRunOutput,
+        session_state: Optional[Dict[str, Any]] = None,
+        stream_intermediate_steps: bool = False,
+        **kwargs: Any,
+    ) -> Iterator[WorkflowRunOutputEvent]:
+        """Execute a specific pipeline by name with event streaming"""
+        from inspect import isasyncgenfunction, iscoroutinefunction, isgeneratorfunction
+
+        workflow_run_response.status = RunStatus.running
+
+        # Register run for cancellation tracking
+        if workflow_run_response.run_id:
+            register_run(workflow_run_response.run_id)
+
+        workflow_started_event = WorkflowStartedEvent(
+            run_id=workflow_run_response.run_id or "",
+            workflow_name=workflow_run_response.workflow_name,
+            workflow_id=workflow_run_response.workflow_id,
+            session_id=workflow_run_response.session_id,
+        )
+        yield self._handle_event(workflow_started_event, workflow_run_response)
+
+        if callable(self.steps):
+            if iscoroutinefunction(self.steps) or isasyncgenfunction(self.steps):
+                raise ValueError("Cannot use async function with synchronous execution")
+            elif isgeneratorfunction(self.steps):
+                content = ""
+                for chunk in self._call_custom_function(self.steps, execution_input, **kwargs):  # type: ignore[arg-type]
+                    raise_if_cancelled(workflow_run_response.run_id)  # type: ignore
+                    # Update the run_response with the content from the result
+                    if hasattr(chunk, "content") and chunk.content is not None and isinstance(chunk.content, str):
+                        content += chunk.content
+                        yield chunk
+                    else:
+                        content += str(chunk)
+                workflow_run_response.content = content
+            else:
+                raise_if_cancelled(workflow_run_response.run_id)  # type: ignore
+                workflow_run_response.content = self._call_custom_function(self.steps, execution_input, **kwargs)
+            workflow_run_response.status = RunStatus.completed
+
+        else:
+            try:
+                # Track outputs from each step for enhanced data flow
+                collected_step_outputs: List[Union[StepOutput, List[StepOutput]]] = []
+                previous_step_outputs: Dict[str, StepOutput] = {}
+
+                shared_images: List[ImageArtifact] = execution_input.images or []
+                output_images: List[ImageArtifact] = (execution_input.images or []).copy()  # Start with input images
+                shared_videos: List[VideoArtifact] = execution_input.videos or []
+                output_videos: List[VideoArtifact] = (execution_input.videos or []).copy()  # Start with input videos
+                shared_audio: List[AudioArtifact] = execution_input.audio or []
+                output_audio: List[AudioArtifact] = (execution_input.audio or []).copy()  # Start with input audio
+                shared_files: List[File] = execution_input.files or []
+                output_files: List[File] = (execution_input.files or []).copy()  # Start with input files
+
+                early_termination = False
+
+                for i, step in enumerate(self.steps):  # type: ignore[arg-type]
+                    raise_if_cancelled(workflow_run_response.run_id)  # type: ignore
+                    step_name = getattr(step, "name", f"step_{i + 1}")
+                    log_debug(f"Streaming step {i + 1}/{self._get_step_count()}: {step_name}")
+
+                    # Create enhanced StepInput
+                    step_input = self._create_step_input(
+                        execution_input=execution_input,
+                        previous_step_outputs=previous_step_outputs,
+                        shared_images=shared_images,
+                        shared_videos=shared_videos,
+                        shared_audio=shared_audio,
+                        shared_files=shared_files,
+                    )
+
+                    # Execute step with streaming and yield all events
+                    for event in step.execute_stream(  # type: ignore[union-attr]
+                        step_input,
+                        session_id=session.session_id,
+                        user_id=self.user_id,
+                        stream_intermediate_steps=stream_intermediate_steps,
+                        workflow_run_response=workflow_run_response,
+                        session_state=session_state,
+                        step_index=i,
+                        store_executor_outputs=self.store_executor_outputs,
+                    ):
+                        raise_if_cancelled(workflow_run_response.run_id)  # type: ignore
+                        # Handle events
+                        if isinstance(event, StepOutput):
+                            step_output = event
+                            collected_step_outputs.append(step_output)
+
+                            # Update the workflow-level previous_step_outputs dictionary
+                            previous_step_outputs[step_name] = step_output
+
+                            # Transform StepOutput to StepOutputEvent for consistent streaming interface
+                            step_output_event = self._transform_step_output_to_event(
+                                step_output, workflow_run_response, step_index=i
+                            )
+
+                            if step_output.stop:
+                                logger.info(f"Early termination requested by step {step_name}")
+                                # Update shared media for next step
+                                shared_images.extend(step_output.images or [])
+                                shared_videos.extend(step_output.videos or [])
+                                shared_audio.extend(step_output.audio or [])
+                                shared_files.extend(step_output.files or [])
+                                output_images.extend(step_output.images or [])
+                                output_videos.extend(step_output.videos or [])
+                                output_audio.extend(step_output.audio or [])
+                                output_files.extend(step_output.files or [])
+
+                                # Only yield StepOutputEvent for function executors, not for agents/teams
+                                if getattr(step, "executor_type", None) == "function":
+                                    yield step_output_event
+
+                                # Break out of the step loop
+                                early_termination = True
+                                break
+
+                            # Update shared media for next step
+                            shared_images.extend(step_output.images or [])
+                            shared_videos.extend(step_output.videos or [])
+                            shared_audio.extend(step_output.audio or [])
+                            shared_files.extend(step_output.files or [])
+                            output_images.extend(step_output.images or [])
+                            output_videos.extend(step_output.videos or [])
+                            output_audio.extend(step_output.audio or [])
+                            output_files.extend(step_output.files or [])
+
+                            # Only yield StepOutputEvent for generator functions, not for agents/teams
+                            if getattr(step, "executor_type", None) == "function":
+                                yield step_output_event
+
+                        elif isinstance(event, WorkflowRunOutputEvent):  # type: ignore
+                            yield self._handle_event(event, workflow_run_response)  # type: ignore
+
+                        else:
+                            # Yield other internal events
+                            yield self._handle_event(event, workflow_run_response)  # type: ignore
+
+                    # Break out of main step loop if early termination was requested
+                    if "early_termination" in locals() and early_termination:
+                        break
+
+                # Update the workflow_run_response with completion data
+                if collected_step_outputs:
+                    workflow_run_response.metrics = self._aggregate_workflow_metrics(collected_step_outputs)
+                    last_output = cast(StepOutput, collected_step_outputs[-1])
+
+                    # Use deepest nested content if this is a container (Steps/Router/Loop/etc.)
+                    if getattr(last_output, "steps", None):
+                        _cur = last_output
+                        while getattr(_cur, "steps", None):
+                            _steps = _cur.steps or []
+                            if not _steps:
+                                break
+                            _cur = _steps[-1]
+                        workflow_run_response.content = _cur.content
+                    else:
+                        workflow_run_response.content = last_output.content
+                else:
+                    workflow_run_response.content = "No steps executed"
+
+                workflow_run_response.step_results = collected_step_outputs
+                workflow_run_response.images = output_images
+                workflow_run_response.videos = output_videos
+                workflow_run_response.audio = output_audio
+                workflow_run_response.status = RunStatus.completed
+
+            except RunCancelledException as e:
+                # Handle run cancellation during streaming
+                logger.info(f"Workflow run {workflow_run_response.run_id} was cancelled during streaming")
+                workflow_run_response.status = RunStatus.cancelled
+                workflow_run_response.content = str(e)
+                cancelled_event = WorkflowCancelledEvent(
+                    run_id=workflow_run_response.run_id or "",
+                    workflow_id=self.id,
+                    workflow_name=self.name,
+                    session_id=session.session_id,
+                    reason=str(e),
+                )
+                yield self._handle_event(cancelled_event, workflow_run_response)
+            except Exception as e:
+                logger.error(f"Workflow execution failed: {e}")
+
+                from agno.run.workflow import WorkflowErrorEvent
+
+                error_event = WorkflowErrorEvent(
+                    run_id=workflow_run_response.run_id or "",
+                    workflow_id=self.id,
+                    workflow_name=self.name,
+                    session_id=session.session_id,
+                    error=str(e),
+                )
+
+                yield error_event
+
+                # Update workflow_run_response with error
+                workflow_run_response.content = error_event.error
+                workflow_run_response.status = RunStatus.error
+
+        # Yield workflow completed event
+        workflow_completed_event = WorkflowCompletedEvent(
+            run_id=workflow_run_response.run_id or "",
+            content=workflow_run_response.content,
+            workflow_name=workflow_run_response.workflow_name,
+            workflow_id=workflow_run_response.workflow_id,
+            session_id=workflow_run_response.session_id,
+            step_results=workflow_run_response.step_results,  # type: ignore
+            metadata=workflow_run_response.metadata,
+        )
+        yield self._handle_event(workflow_completed_event, workflow_run_response)
+
+        # Store the completed workflow response
+        self._update_session_metrics(session=session, workflow_run_response=workflow_run_response)
+        session.upsert_run(run=workflow_run_response)
+        self.save_session(session=session)
+
+        # Always clean up the run tracking
+        cleanup_run(workflow_run_response.run_id)  # type: ignore
+
+        # Log Workflow Telemetry
+        if self.telemetry:
+            self._log_workflow_telemetry(session_id=session.session_id, run_id=workflow_run_response.run_id)
+
+    async def _acall_custom_function(
+        self, func: Callable, execution_input: WorkflowExecutionInput, **kwargs: Any
+    ) -> Any:
+        """Call custom function with only the parameters it expects - handles both async functions and async generators"""
+        from inspect import isasyncgenfunction, signature
+
+        sig = signature(func)
+
+        # Build arguments based on what the function actually accepts
+        call_kwargs: Dict[str, Any] = {}
+
+        # Only add workflow and execution_input if the function expects them
+        if "workflow" in sig.parameters:  # type: ignore
+            call_kwargs["workflow"] = self
+        if "execution_input" in sig.parameters:
+            call_kwargs["execution_input"] = execution_input  # type: ignore
+        if "session_state" in sig.parameters:
+            call_kwargs["session_state"] = self.session_state  # type: ignore
+
+        # Add any other kwargs that the function expects
+        for param_name in kwargs:
+            if param_name in sig.parameters:  # type: ignore
+                call_kwargs[param_name] = kwargs[param_name]
+
+        # If function has **kwargs parameter, pass all remaining kwargs
+        for param in sig.parameters.values():  # type: ignore
+            if param.kind == param.VAR_KEYWORD:
+                call_kwargs.update(kwargs)
+                break
+
+        try:
+            # Check if it's an async generator function
+            if isasyncgenfunction(func):
+                # For async generators, call the function and return the async generator directly
+                return func(**call_kwargs)  # type: ignore
+            else:
+                # For regular async functions, await the result
+                return await func(**call_kwargs)  # type: ignore
+        except TypeError as e:
+            # If signature inspection fails, fall back to original method
+            logger.warning(
+                f"Async function signature inspection failed: {e}. Falling back to original calling convention."
             )
-            # Important: Replace the instance's run method with run_workflow
-            # This is so we call run_workflow() instead of the subclass's run()
-            if run_type == "sync":
-                object.__setattr__(self, "run", self.run_workflow.__get__(self))
-            elif run_type == "coroutine":
-                object.__setattr__(self, "arun", self.arun_workflow.__get__(self))
-            elif run_type == "async_generator":
-                object.__setattr__(self, "arun", self.arun_workflow_generator.__get__(self))
+            if isasyncgenfunction(func):
+                # For async generators, use the same signature inspection logic in fallback
+                return func(**call_kwargs)  # type: ignore
+            else:
+                # For regular async functions, use the same signature inspection logic in fallback
+                return await func(**call_kwargs)  # type: ignore
+
+    async def _aexecute(
+        self,
+        session: WorkflowSession,
+        execution_input: WorkflowExecutionInput,
+        workflow_run_response: WorkflowRunOutput,
+        session_state: Optional[Dict[str, Any]] = None,
+        **kwargs: Any,
+    ) -> WorkflowRunOutput:
+        """Execute a specific pipeline by name asynchronously"""
+        from inspect import isasyncgenfunction, iscoroutinefunction, isgeneratorfunction
+
+        workflow_run_response.status = RunStatus.running
+
+        # Register run for cancellation tracking
+        register_run(workflow_run_response.run_id)  # type: ignore
+
+        if callable(self.steps):
+            # Execute the workflow with the custom executor
+            content = ""
+
+            if iscoroutinefunction(self.steps):  # type: ignore
+                workflow_run_response.content = await self._acall_custom_function(self.steps, execution_input, **kwargs)
+            elif isgeneratorfunction(self.steps):
+                for chunk in self.steps(self, execution_input, **kwargs):  # type: ignore[arg-type]
+                    if hasattr(chunk, "content") and chunk.content is not None and isinstance(chunk.content, str):
+                        content += chunk.content
+                    else:
+                        content += str(chunk)
+                workflow_run_response.content = content
+            elif isasyncgenfunction(self.steps):  # type: ignore
+                async_gen = await self._acall_custom_function(self.steps, execution_input, **kwargs)
+                async for chunk in async_gen:
+                    raise_if_cancelled(workflow_run_response.run_id)  # type: ignore
+                    if hasattr(chunk, "content") and chunk.content is not None and isinstance(chunk.content, str):
+                        content += chunk.content
+                    else:
+                        content += str(chunk)
+                workflow_run_response.content = content
+            else:
+                raise_if_cancelled(workflow_run_response.run_id)  # type: ignore
+                workflow_run_response.content = self._call_custom_function(self.steps, execution_input, **kwargs)
+            workflow_run_response.status = RunStatus.completed
+
         else:
-            # If the subclass does not override the run method,
-            # the Workflow.run() method will be called and will log an error
-            self._subclass_run = self.run
-            self._subclass_arun = self.arun
-
-            self._run_parameters = {}
-            self._run_return_type = None
-
-    def update_agent_session_ids(self):
-        # Update the session_id for all Agent instances
-        # use dataclasses.fields() to iterate through fields
-        for f in fields(self):
-            field_type = f.type
-            if isinstance(field_type, Agent):
-                field_value = getattr(self, f.name)
-                field_value.session_id = self.session_id
-
-    def get_workflow_data(self) -> Dict[str, Any]:
-        workflow_data: Dict[str, Any] = {}
-        if self.name is not None:
-            workflow_data["name"] = self.name
-        if self.workflow_id is not None:
-            workflow_data["workflow_id"] = self.workflow_id
-        if self.description is not None:
-            workflow_data["description"] = self.description
-        return workflow_data
+            try:
+                # Track outputs from each step for enhanced data flow
+                collected_step_outputs: List[Union[StepOutput, List[StepOutput]]] = []
+                previous_step_outputs: Dict[str, StepOutput] = {}
+
+                shared_images: List[ImageArtifact] = execution_input.images or []
+                output_images: List[ImageArtifact] = (execution_input.images or []).copy()  # Start with input images
+                shared_videos: List[VideoArtifact] = execution_input.videos or []
+                output_videos: List[VideoArtifact] = (execution_input.videos or []).copy()  # Start with input videos
+                shared_audio: List[AudioArtifact] = execution_input.audio or []
+                output_audio: List[AudioArtifact] = (execution_input.audio or []).copy()  # Start with input audio
+                shared_files: List[File] = execution_input.files or []
+                output_files: List[File] = (execution_input.files or []).copy()  # Start with input files
+
+                for i, step in enumerate(self.steps):  # type: ignore[arg-type]
+                    raise_if_cancelled(workflow_run_response.run_id)  # type: ignore
+                    step_name = getattr(step, "name", f"step_{i + 1}")
+                    log_debug(f"Async Executing step {i + 1}/{self._get_step_count()}: {step_name}")
+
+                    # Create enhanced StepInput
+                    step_input = self._create_step_input(
+                        execution_input=execution_input,
+                        previous_step_outputs=previous_step_outputs,
+                        shared_images=shared_images,
+                        shared_videos=shared_videos,
+                        shared_audio=shared_audio,
+                        shared_files=shared_files,
+                    )
+
+                    # Check for cancellation before executing step
+                    raise_if_cancelled(workflow_run_response.run_id)  # type: ignore
+
+                    step_output = await step.aexecute(  # type: ignore[union-attr]
+                        step_input,
+                        session_id=session.session_id,
+                        user_id=self.user_id,
+                        workflow_run_response=workflow_run_response,
+                        session_state=session_state,
+                        store_executor_outputs=self.store_executor_outputs,
+                    )
+
+                    # Check for cancellation after step execution
+                    raise_if_cancelled(workflow_run_response.run_id)  # type: ignore
+
+                    # Update the workflow-level previous_step_outputs dictionary
+                    previous_step_outputs[step_name] = step_output
+                    if step_output.stop:
+                        logger.info(f"Early termination requested by step {step_name}")
+                        break
+
+                    # Update shared media for next step
+                    shared_images.extend(step_output.images or [])
+                    shared_videos.extend(step_output.videos or [])
+                    shared_audio.extend(step_output.audio or [])
+                    shared_files.extend(step_output.files or [])
+                    output_images.extend(step_output.images or [])
+                    output_videos.extend(step_output.videos or [])
+                    output_audio.extend(step_output.audio or [])
+                    output_files.extend(step_output.files or [])
+
+                    collected_step_outputs.append(step_output)
+
+                # Update the workflow_run_response with completion data
+                if collected_step_outputs:
+                    workflow_run_response.metrics = self._aggregate_workflow_metrics(collected_step_outputs)
+                    last_output = cast(StepOutput, collected_step_outputs[-1])
+
+                    # Use deepest nested content if this is a container (Steps/Router/Loop/etc.)
+                    if getattr(last_output, "steps", None):
+                        _cur = last_output
+                        while getattr(_cur, "steps", None):
+                            _steps = _cur.steps or []
+                            if not _steps:
+                                break
+                            _cur = _steps[-1]
+                        workflow_run_response.content = _cur.content
+                    else:
+                        workflow_run_response.content = last_output.content
+                else:
+                    workflow_run_response.content = "No steps executed"
+
+                workflow_run_response.step_results = collected_step_outputs
+                workflow_run_response.images = output_images
+                workflow_run_response.videos = output_videos
+                workflow_run_response.audio = output_audio
+                workflow_run_response.status = RunStatus.completed
+
+            except RunCancelledException as e:
+                logger.info(f"Workflow run {workflow_run_response.run_id} was cancelled")
+                workflow_run_response.status = RunStatus.cancelled
+                workflow_run_response.content = str(e)
+            except Exception as e:
+                logger.error(f"Workflow execution failed: {e}")
+                workflow_run_response.status = RunStatus.error
+                workflow_run_response.content = f"Workflow execution failed: {e}"
+
+        self._update_session_metrics(session=session, workflow_run_response=workflow_run_response)
+        session.upsert_run(run=workflow_run_response)
+        self.save_session(session=session)
+        # Always clean up the run tracking
+        cleanup_run(workflow_run_response.run_id)  # type: ignore
 
-    def get_session_data(self) -> Dict[str, Any]:
-        session_data: Dict[str, Any] = {}
-        if self.session_name is not None:
-            session_data["session_name"] = self.session_name
-        if self.session_state and len(self.session_state) > 0:
-            session_data["session_state"] = nested_model_dump(self.session_state)
-        if self.images is not None:
-            session_data["images"] = [img.model_dump() for img in self.images]
-        if self.videos is not None:
-            session_data["videos"] = [vid.model_dump() for vid in self.videos]
-        if self.audio is not None:
-            session_data["audio"] = [aud.model_dump() for aud in self.audio]
-        return session_data
-
-    def get_workflow_session(self) -> WorkflowSession:
-        """Get a WorkflowSession object, which can be saved to the database"""
-        self.memory = cast(WorkflowMemory, self.memory)
-        self.session_id = cast(str, self.session_id)
-        self.workflow_id = cast(str, self.workflow_id)
-        if self.memory is not None:
-            if isinstance(self.memory, WorkflowMemory):
-                self.memory = cast(WorkflowMemory, self.memory)
-                memory_dict = self.memory.to_dict()
-                # We only persist the runs for the current session ID (not all runs in memory)
-                memory_dict["runs"] = [
-                    agent_run.model_dump()
-                    for agent_run in self.memory.runs
-                    if agent_run.response is not None and agent_run.response.session_id == self.session_id
-                ]
+        # Log Workflow Telemetry
+        if self.telemetry:
+            await self._alog_workflow_telemetry(session_id=session.session_id, run_id=workflow_run_response.run_id)
+
+        return workflow_run_response
+
+    async def _aexecute_stream(
+        self,
+        session: WorkflowSession,
+        execution_input: WorkflowExecutionInput,
+        workflow_run_response: WorkflowRunOutput,
+        session_state: Optional[Dict[str, Any]] = None,
+        stream_intermediate_steps: bool = False,
+        websocket_handler: Optional[WebSocketHandler] = None,
+        **kwargs: Any,
+    ) -> AsyncIterator[WorkflowRunOutputEvent]:
+        """Execute a specific pipeline by name with event streaming"""
+        from inspect import isasyncgenfunction, iscoroutinefunction, isgeneratorfunction
+
+        workflow_run_response.status = RunStatus.running
+        workflow_started_event = WorkflowStartedEvent(
+            run_id=workflow_run_response.run_id or "",
+            workflow_name=workflow_run_response.workflow_name,
+            workflow_id=workflow_run_response.workflow_id,
+            session_id=workflow_run_response.session_id,
+        )
+        yield self._handle_event(workflow_started_event, workflow_run_response, websocket_handler=websocket_handler)
+
+        if callable(self.steps):
+            if iscoroutinefunction(self.steps):  # type: ignore
+                workflow_run_response.content = await self._acall_custom_function(self.steps, execution_input, **kwargs)
+            elif isgeneratorfunction(self.steps):
+                content = ""
+                for chunk in self.steps(self, execution_input, **kwargs):  # type: ignore[arg-type]
+                    if hasattr(chunk, "content") and chunk.content is not None and isinstance(chunk.content, str):
+                        content += chunk.content
+                        yield chunk
+                    else:
+                        content += str(chunk)
+                workflow_run_response.content = content
+            elif isasyncgenfunction(self.steps):  # type: ignore
+                content = ""
+                async_gen = await self._acall_custom_function(self.steps, execution_input, **kwargs)
+                async for chunk in async_gen:
+                    raise_if_cancelled(workflow_run_response.run_id)  # type: ignore
+                    if hasattr(chunk, "content") and chunk.content is not None and isinstance(chunk.content, str):
+                        content += chunk.content
+                        yield chunk
+                    else:
+                        content += str(chunk)
+                workflow_run_response.content = content
             else:
-                self.memory = cast(Memory, self.memory)
-                # We fake the structure on storage, to maintain the interface with the legacy implementation
-                run_responses = self.memory.runs[self.session_id]  # type: ignore
-                memory_dict = self.memory.to_dict()
-                memory_dict["runs"] = [rr.to_dict() for rr in run_responses]
+                workflow_run_response.content = self.steps(self, execution_input, **kwargs)
+            workflow_run_response.status = RunStatus.completed
+
         else:
-            memory_dict = None
-        return WorkflowSession(
-            session_id=self.session_id,
-            workflow_id=self.workflow_id,
-            user_id=self.user_id,
-            memory=memory_dict,
-            workflow_data=self.get_workflow_data(),
-            session_data=self.get_session_data(),
-            extra_data=self.extra_data,
+            try:
+                # Track outputs from each step for enhanced data flow
+                collected_step_outputs: List[Union[StepOutput, List[StepOutput]]] = []
+                previous_step_outputs: Dict[str, StepOutput] = {}
+
+                shared_images: List[ImageArtifact] = execution_input.images or []
+                output_images: List[ImageArtifact] = (execution_input.images or []).copy()  # Start with input images
+                shared_videos: List[VideoArtifact] = execution_input.videos or []
+                output_videos: List[VideoArtifact] = (execution_input.videos or []).copy()  # Start with input videos
+                shared_audio: List[AudioArtifact] = execution_input.audio or []
+                output_audio: List[AudioArtifact] = (execution_input.audio or []).copy()  # Start with input audio
+                shared_files: List[File] = execution_input.files or []
+                output_files: List[File] = (execution_input.files or []).copy()  # Start with input files
+
+                early_termination = False
+
+                for i, step in enumerate(self.steps):  # type: ignore[arg-type]
+                    if workflow_run_response.run_id:
+                        raise_if_cancelled(workflow_run_response.run_id)
+                    step_name = getattr(step, "name", f"step_{i + 1}")
+                    log_debug(f"Async streaming step {i + 1}/{self._get_step_count()}: {step_name}")
+
+                    # Create enhanced StepInput
+                    step_input = self._create_step_input(
+                        execution_input=execution_input,
+                        previous_step_outputs=previous_step_outputs,
+                        shared_images=shared_images,
+                        shared_videos=shared_videos,
+                        shared_audio=shared_audio,
+                        shared_files=shared_files,
+                    )
+
+                    # Execute step with streaming and yield all events
+                    async for event in step.aexecute_stream(  # type: ignore[union-attr]
+                        step_input,
+                        session_id=session.session_id,
+                        user_id=self.user_id,
+                        stream_intermediate_steps=stream_intermediate_steps,
+                        workflow_run_response=workflow_run_response,
+                        session_state=session_state,
+                        step_index=i,
+                        store_executor_outputs=self.store_executor_outputs,
+                    ):
+                        if workflow_run_response.run_id:
+                            raise_if_cancelled(workflow_run_response.run_id)
+                        if isinstance(event, StepOutput):
+                            step_output = event
+                            collected_step_outputs.append(step_output)
+
+                            # Update the workflow-level previous_step_outputs dictionary
+                            previous_step_outputs[step_name] = step_output
+
+                            # Transform StepOutput to StepOutputEvent for consistent streaming interface
+                            step_output_event = self._transform_step_output_to_event(
+                                step_output, workflow_run_response, step_index=i
+                            )
+
+                            if step_output.stop:
+                                logger.info(f"Early termination requested by step {step_name}")
+                                # Update shared media for next step
+                                shared_images.extend(step_output.images or [])
+                                shared_videos.extend(step_output.videos or [])
+                                shared_audio.extend(step_output.audio or [])
+                                shared_files.extend(step_output.files or [])
+                                output_images.extend(step_output.images or [])
+                                output_videos.extend(step_output.videos or [])
+                                output_audio.extend(step_output.audio or [])
+                                output_files.extend(step_output.files or [])
+
+                                if getattr(step, "executor_type", None) == "function":
+                                    yield step_output_event
+
+                                # Break out of the step loop
+                                early_termination = True
+                                break
+
+                            # Update shared media for next step
+                            shared_images.extend(step_output.images or [])
+                            shared_videos.extend(step_output.videos or [])
+                            shared_audio.extend(step_output.audio or [])
+                            shared_files.extend(step_output.files or [])
+                            output_images.extend(step_output.images or [])
+                            output_videos.extend(step_output.videos or [])
+                            output_audio.extend(step_output.audio or [])
+                            output_files.extend(step_output.files or [])
+
+                            # Only yield StepOutputEvent for generator functions, not for agents/teams
+                            if getattr(step, "executor_type", None) == "function":
+                                yield step_output_event
+
+                        elif isinstance(event, WorkflowRunOutputEvent):  # type: ignore
+                            yield self._handle_event(event, workflow_run_response, websocket_handler=websocket_handler)  # type: ignore
+
+                        else:
+                            # Yield other internal events
+                            yield self._handle_event(event, workflow_run_response, websocket_handler=websocket_handler)  # type: ignore
+
+                    # Break out of main step loop if early termination was requested
+                    if "early_termination" in locals() and early_termination:
+                        break
+
+                # Update the workflow_run_response with completion data
+                if collected_step_outputs:
+                    workflow_run_response.metrics = self._aggregate_workflow_metrics(collected_step_outputs)
+                    last_output = cast(StepOutput, collected_step_outputs[-1])
+
+                    # Use deepest nested content if this is a container (Steps/Router/Loop/etc.)
+                    if getattr(last_output, "steps", None):
+                        _cur = last_output
+                        while getattr(_cur, "steps", None):
+                            _steps = _cur.steps or []
+                            if not _steps:
+                                break
+                            _cur = _steps[-1]
+                        workflow_run_response.content = _cur.content
+                    else:
+                        workflow_run_response.content = last_output.content
+                else:
+                    workflow_run_response.content = "No steps executed"
+
+                workflow_run_response.step_results = collected_step_outputs
+                workflow_run_response.images = output_images
+                workflow_run_response.videos = output_videos
+                workflow_run_response.audio = output_audio
+                workflow_run_response.status = RunStatus.completed
+
+            except RunCancelledException as e:
+                # Handle run cancellation during streaming
+                logger.info(f"Workflow run {workflow_run_response.run_id} was cancelled during streaming")
+                workflow_run_response.status = RunStatus.cancelled
+                workflow_run_response.content = str(e)
+                cancelled_event = WorkflowCancelledEvent(
+                    run_id=workflow_run_response.run_id or "",
+                    workflow_id=self.id,
+                    workflow_name=self.name,
+                    session_id=session.session_id,
+                    reason=str(e),
+                )
+                yield self._handle_event(
+                    cancelled_event,
+                    workflow_run_response,
+                    websocket_handler=websocket_handler,
+                )
+            except Exception as e:
+                logger.error(f"Workflow execution failed: {e}")
+
+                from agno.run.workflow import WorkflowErrorEvent
+
+                error_event = WorkflowErrorEvent(
+                    run_id=workflow_run_response.run_id or "",
+                    workflow_id=self.id,
+                    workflow_name=self.name,
+                    session_id=session.session_id,
+                    error=str(e),
+                )
+
+                yield error_event
+
+                # Update workflow_run_response with error
+                workflow_run_response.content = error_event.error
+                workflow_run_response.status = RunStatus.error
+
+        # Yield workflow completed event
+        workflow_completed_event = WorkflowCompletedEvent(
+            run_id=workflow_run_response.run_id or "",
+            content=workflow_run_response.content,
+            workflow_name=workflow_run_response.workflow_name,
+            workflow_id=workflow_run_response.workflow_id,
+            session_id=workflow_run_response.session_id,
+            step_results=workflow_run_response.step_results,  # type: ignore[arg-type]
+            metadata=workflow_run_response.metadata,
         )
+        yield self._handle_event(workflow_completed_event, workflow_run_response, websocket_handler=websocket_handler)
 
-    def load_workflow_session(self, session: WorkflowSession):
-        """Load the existing Workflow from a WorkflowSession (from the database)"""
+        # Store the completed workflow response
+        self._update_session_metrics(session=session, workflow_run_response=workflow_run_response)
+        session.upsert_run(run=workflow_run_response)
+        self.save_session(session=session)
+
+        # Log Workflow Telemetry
+        if self.telemetry:
+            await self._alog_workflow_telemetry(session_id=session.session_id, run_id=workflow_run_response.run_id)
+
+        # Always clean up the run tracking
+        cleanup_run(workflow_run_response.run_id)  # type: ignore
+
+    async def _arun_background(
+        self,
+        input: Optional[Union[str, Dict[str, Any], List[Any], BaseModel, List[Message]]] = None,
+        additional_data: Optional[Dict[str, Any]] = None,
+        user_id: Optional[str] = None,
+        session_id: Optional[str] = None,
+        session_state: Optional[Dict[str, Any]] = None,
+        audio: Optional[List[Audio]] = None,
+        images: Optional[List[Image]] = None,
+        videos: Optional[List[Video]] = None,
+        files: Optional[List[File]] = None,
+        **kwargs: Any,
+    ) -> WorkflowRunOutput:
+        """Execute workflow in background using asyncio.create_task()"""
+
+        run_id = str(uuid4())
+
+        self.initialize_workflow()
+
+        session_id, user_id, session_state = self._initialize_session(
+            session_id=session_id, user_id=user_id, session_state=session_state, run_id=run_id
+        )
+
+        # Read existing session from database
+        workflow_session = self.read_or_create_session(session_id=session_id, user_id=user_id)
+        self._update_metadata(session=workflow_session)
+
+        # Update session state from DB
+        session_state = self._update_session_state(session=workflow_session, session_state=session_state)
+
+        self._prepare_steps()
+
+        # Create workflow run response with PENDING status
+        workflow_run_response = WorkflowRunOutput(
+            run_id=run_id,
+            session_id=session_id,
+            workflow_id=self.id,
+            workflow_name=self.name,
+            created_at=int(datetime.now().timestamp()),
+            status=RunStatus.pending,
+        )
+
+        # Store PENDING response immediately
+        workflow_session.upsert_run(run=workflow_run_response)
+        self.save_session(session=workflow_session)
+
+        # Prepare execution input
+        inputs = WorkflowExecutionInput(
+            input=input,
+            additional_data=additional_data,
+            audio=audio,  # type: ignore
+            images=images,  # type: ignore
+            videos=videos,  # type: ignore
+            files=files,  # type: ignore
+        )
+
+        self.update_agents_and_teams_session_info()
+
+        async def execute_workflow_background():
+            """Simple background execution"""
+            try:
+                # Update status to RUNNING and save
+                workflow_run_response.status = RunStatus.running
+                self.save_session(session=workflow_session)
+
+                await self._aexecute(
+                    session=workflow_session,
+                    execution_input=inputs,
+                    workflow_run_response=workflow_run_response,
+                    session_state=session_state,
+                    **kwargs,
+                )
+
+                log_debug(f"Background execution completed with status: {workflow_run_response.status}")
+
+            except Exception as e:
+                logger.error(f"Background workflow execution failed: {e}")
+                workflow_run_response.status = RunStatus.error
+                workflow_run_response.content = f"Background execution failed: {str(e)}"
+                self.save_session(session=workflow_session)
+
+        # Create and start asyncio task
+        loop = asyncio.get_running_loop()
+        loop.create_task(execute_workflow_background())
+
+        # Return SAME object that will be updated by background execution
+        return workflow_run_response
+
+    async def _arun_background_stream(
+        self,
+        input: Optional[Union[str, Dict[str, Any], List[Any], BaseModel, List[Message]]] = None,
+        additional_data: Optional[Dict[str, Any]] = None,
+        user_id: Optional[str] = None,
+        session_id: Optional[str] = None,
+        session_state: Optional[Dict[str, Any]] = None,
+        audio: Optional[List[Audio]] = None,
+        images: Optional[List[Image]] = None,
+        videos: Optional[List[Video]] = None,
+        files: Optional[List[File]] = None,
+        stream_intermediate_steps: bool = False,
+        websocket_handler: Optional[WebSocketHandler] = None,
+        **kwargs: Any,
+    ) -> WorkflowRunOutput:
+        """Execute workflow in background with streaming and WebSocket broadcasting"""
+
+        run_id = str(uuid4())
+
+        self.initialize_workflow()
+
+        session_id, user_id, session_state = self._initialize_session(
+            session_id=session_id, user_id=user_id, session_state=session_state, run_id=run_id
+        )
+
+        # Read existing session from database
+        workflow_session = self.read_or_create_session(session_id=session_id, user_id=user_id)
+        self._update_metadata(session=workflow_session)
+
+        # Update session state from DB
+        session_state = self._update_session_state(session=workflow_session, session_state=session_state)
+
+        self._prepare_steps()
 
-        # Get the workflow_id, user_id and session_id from the database
-        if self.workflow_id is None and session.workflow_id is not None:
-            self.workflow_id = session.workflow_id
-        if self.user_id is None and session.user_id is not None:
-            self.user_id = session.user_id
-        if self.session_id is None and session.session_id is not None:
-            self.session_id = session.session_id
-
-        # Read workflow_data from the database
-        if session.workflow_data is not None:
-            # Get name from database and update the workflow name if not set
-            if self.name is None and "name" in session.workflow_data:
-                self.name = session.workflow_data.get("name")
-
-        # Read session_data from the database
-        if session.session_data is not None:
-            # Get the session_name from database and update the current session_name if not set
-            if self.session_name is None and "session_name" in session.session_data:
-                self.session_name = session.session_data.get("session_name")
-
-            # Get the session_state from database and update the current session_state
-            if "session_state" in session.session_data:
-                session_state_from_db = session.session_data.get("session_state")
-                if (
-                    session_state_from_db is not None
-                    and isinstance(session_state_from_db, dict)
-                    and len(session_state_from_db) > 0
+        # Create workflow run response with PENDING status
+        workflow_run_response = WorkflowRunOutput(
+            run_id=run_id,
+            session_id=session_id,
+            workflow_id=self.id,
+            workflow_name=self.name,
+            created_at=int(datetime.now().timestamp()),
+            status=RunStatus.pending,
+        )
+
+        # Store PENDING response immediately
+        workflow_session.upsert_run(run=workflow_run_response)
+        self.save_session(session=workflow_session)
+
+        # Prepare execution input
+        inputs = WorkflowExecutionInput(
+            input=input,
+            additional_data=additional_data,
+            audio=audio,  # type: ignore
+            images=images,  # type: ignore
+            videos=videos,  # type: ignore
+            files=files,  # type: ignore
+        )
+
+        self.update_agents_and_teams_session_info()
+
+        async def execute_workflow_background_stream():
+            """Background execution with streaming and WebSocket broadcasting"""
+            try:
+                # Update status to RUNNING and save
+                workflow_run_response.status = RunStatus.running
+                self.save_session(session=workflow_session)
+
+                # Execute with streaming - consume all events (they're auto-broadcast via _handle_event)
+                async for event in self._aexecute_stream(
+                    execution_input=inputs,
+                    session=workflow_session,
+                    workflow_run_response=workflow_run_response,
+                    stream_intermediate_steps=stream_intermediate_steps,
+                    session_state=session_state,
+                    websocket_handler=websocket_handler,
+                    **kwargs,
                 ):
-                    # If the session_state is already set, merge the session_state from the database with the current session_state
-                    if len(self.session_state) > 0:
-                        # This updates session_state_from_db
-                        merge_dictionaries(session_state_from_db, self.session_state)
-                    # Update the current session_state
-                    self.session_state = session_state_from_db
-
-            # Get images, videos, and audios from the database
-            if "images" in session.session_data:
-                images_from_db = session.session_data.get("images")
-                if images_from_db is not None and isinstance(images_from_db, list):
-                    if self.images is None:
-                        self.images = []
-                    self.images.extend([ImageArtifact.model_validate(img) for img in images_from_db])
-            if "videos" in session.session_data:
-                videos_from_db = session.session_data.get("videos")
-                if videos_from_db is not None and isinstance(videos_from_db, list):
-                    if self.videos is None:
-                        self.videos = []
-                    self.videos.extend([VideoArtifact.model_validate(vid) for vid in videos_from_db])
-            if "audio" in session.session_data:
-                audio_from_db = session.session_data.get("audio")
-                if audio_from_db is not None and isinstance(audio_from_db, list):
-                    if self.audio is None:
-                        self.audio = []
-                    self.audio.extend([AudioArtifact.model_validate(aud) for aud in audio_from_db])
-
-        # Read extra_data from the database
-        if session.extra_data is not None:
-            # If extra_data is set in the workflow, update the database extra_data with the workflow's extra_data
-            if self.extra_data is not None:
-                # Updates workflow_session.extra_data in place
-                merge_dictionaries(session.extra_data, self.extra_data)
-            # Update the current extra_data with the extra_data from the database which is updated in place
-            self.extra_data = session.extra_data
-
-        if session.memory is not None:
-            if self.memory is None:
-                self.memory = Memory()
-
-            if isinstance(self.memory, Memory):
-                try:
-                    if self.memory.runs is None:
-                        self.memory.runs = {}
-                    self.memory.runs[session.session_id] = []
-                    for run in session.memory["runs"]:
-                        run_session_id = run["session_id"]
-                        self.memory.runs[run_session_id].append(RunResponse.from_dict(run))
-                except Exception as e:
-                    log_warning(f"Failed to load runs from memory: {e}")
-            else:
-                try:
-                    if "runs" in session.memory:
-                        try:
-                            self.memory.runs = [WorkflowRun(**m) for m in session.memory["runs"]]
-                        except Exception as e:
-                            logger.warning(f"Failed to load runs from memory: {e}")
-                except Exception as e:
-                    logger.warning(f"Failed to load WorkflowMemory: {e}")
+                    # Events are automatically broadcast by _handle_event
+                    # We just consume them here to drive the execution
+                    pass
 
-        log_debug(f"-*- WorkflowSession loaded: {session.session_id}")
+                log_debug(f"Background streaming execution completed with status: {workflow_run_response.status}")
 
-    def read_from_storage(self) -> Optional[WorkflowSession]:
-        """Load the WorkflowSession from storage.
+            except Exception as e:
+                logger.error(f"Background streaming workflow execution failed: {e}")
+                workflow_run_response.status = RunStatus.error
+                workflow_run_response.content = f"Background streaming execution failed: {str(e)}"
+                self.save_session(session=workflow_session)
 
-        Returns:
-            Optional[WorkflowSession]: The loaded WorkflowSession or None if not found.
-        """
-        if self.storage is not None and self.session_id is not None:
-            self.workflow_session = cast(WorkflowSession, self.storage.read(session_id=self.session_id))
-            if self.workflow_session is not None:
-                self.load_workflow_session(session=self.workflow_session)
-        return self.workflow_session
+        # Create and start asyncio task for background streaming execution
+        loop = asyncio.get_running_loop()
+        loop.create_task(execute_workflow_background_stream())
 
-    def write_to_storage(self) -> Optional[WorkflowSession]:
-        """Save the WorkflowSession to storage
+        # Return SAME object that will be updated by background execution
+        return workflow_run_response
+
+    def get_run(self, run_id: str) -> Optional[WorkflowRunOutput]:
+        """Get the status and details of a background workflow run - SIMPLIFIED"""
+        if self.db is not None and self.session_id is not None:
+            session = self.db.get_session(session_id=self.session_id, session_type=SessionType.WORKFLOW)
+            if session and isinstance(session, WorkflowSession) and session.runs:
+                # Find the run by ID
+                for run in session.runs:
+                    if run.run_id == run_id:
+                        return run
+
+        return None
+
+    def cancel_run(self, run_id: str) -> bool:
+        """Cancel a running workflow execution.
+
+        Args:
+            run_id (str): The run_id to cancel.
 
         Returns:
-            Optional[WorkflowSession]: The saved WorkflowSession or None if not saved.
+            bool: True if the run was found and marked for cancellation, False otherwise.
         """
-        if self.storage is not None:
-            self.workflow_session = cast(WorkflowSession, self.storage.upsert(session=self.get_workflow_session()))
-        return self.workflow_session
+        return cancel_run_global(run_id)
 
-    def load_session(self, force: bool = False) -> Optional[str]:
-        """Load an existing session from the database and return the session_id.
-        If a session does not exist, create a new session.
+    @overload
+    def run(
+        self,
+        input: Optional[Union[str, Dict[str, Any], List[Any], BaseModel]] = None,
+        additional_data: Optional[Dict[str, Any]] = None,
+        user_id: Optional[str] = None,
+        session_id: Optional[str] = None,
+        session_state: Optional[Dict[str, Any]] = None,
+        audio: Optional[List[Audio]] = None,
+        images: Optional[List[Image]] = None,
+        videos: Optional[List[Video]] = None,
+        files: Optional[List[File]] = None,
+        stream: Literal[False] = False,
+        stream_intermediate_steps: Optional[bool] = None,
+        background: Optional[bool] = False,
+    ) -> WorkflowRunOutput: ...
+
+    @overload
+    def run(
+        self,
+        input: Optional[Union[str, Dict[str, Any], List[Any], BaseModel]] = None,
+        additional_data: Optional[Dict[str, Any]] = None,
+        user_id: Optional[str] = None,
+        session_id: Optional[str] = None,
+        session_state: Optional[Dict[str, Any]] = None,
+        audio: Optional[List[Audio]] = None,
+        images: Optional[List[Image]] = None,
+        videos: Optional[List[Video]] = None,
+        files: Optional[List[File]] = None,
+        stream: Literal[True] = True,
+        stream_intermediate_steps: Optional[bool] = None,
+        background: Optional[bool] = False,
+    ) -> Iterator[WorkflowRunOutputEvent]: ...
+
+    def run(
+        self,
+        input: Optional[Union[str, Dict[str, Any], List[Any], BaseModel]] = None,
+        additional_data: Optional[Dict[str, Any]] = None,
+        user_id: Optional[str] = None,
+        session_id: Optional[str] = None,
+        session_state: Optional[Dict[str, Any]] = None,
+        audio: Optional[List[Audio]] = None,
+        images: Optional[List[Image]] = None,
+        videos: Optional[List[Video]] = None,
+        files: Optional[List[File]] = None,
+        stream: bool = False,
+        stream_intermediate_steps: Optional[bool] = None,
+        background: Optional[bool] = False,
+        **kwargs: Any,
+    ) -> Union[WorkflowRunOutput, Iterator[WorkflowRunOutputEvent]]:
+        """Execute the workflow synchronously with optional streaming"""
+
+        validated_input = self._validate_input(input)
+        if validated_input is not None:
+            input = validated_input
+
+        if background:
+            raise RuntimeError("Background execution is not supported for sync run()")
+
+        self._set_debug()
+
+        run_id = str(uuid4())
+
+        self.initialize_workflow()
+        session_id, user_id, session_state = self._initialize_session(
+            session_id=session_id, user_id=user_id, session_state=session_state, run_id=run_id
+        )
 
-        - If a session exists in the database, load the session.
-        - If a session does not exist in the database, create a new session.
-        """
-        # If a workflow_session is already loaded, return the session_id from the workflow_session
-        #   if the session_id matches the session_id from the workflow_session
-        if self.workflow_session is not None and not force:
-            if self.session_id is not None and self.workflow_session.session_id == self.session_id:
-                return self.workflow_session.session_id
-
-        # Load an existing session or create a new session
-        if self.storage is not None:
-            # Load existing session if session_id is provided
-            log_debug(f"Reading WorkflowSession: {self.session_id}")
-            self.read_from_storage()
-
-            # Create a new session if it does not exist
-            if self.workflow_session is None:
-                log_debug("-*- Creating new WorkflowSession")
-                # write_to_storage() will create a new WorkflowSession
-                # and populate self.workflow_session with the new session
-                self.write_to_storage()
-                if self.workflow_session is None:
-                    raise Exception("Failed to create new WorkflowSession in storage")
-                log_debug(f"-*- Created WorkflowSession: {self.workflow_session.session_id}")
-                self.log_workflow_session()
-        return self.session_id
-
-    def new_session(self) -> None:
-        """Create a new Workflow session
-
-        - Clear the workflow_session
-        - Create a new session_id
-        - Load the new session
-        """
-        self.workflow_session = None
-        self.session_id = str(uuid4())
-        self.load_session(force=True)
+        # Read existing session from database
+        workflow_session = self.read_or_create_session(session_id=session_id, user_id=user_id)
+        self._update_metadata(session=workflow_session)
 
-    def log_workflow_session(self):
-        log_debug(f"*********** Logging WorkflowSession: {self.session_id} ***********")
+        # Update session state from DB
+        session_state = self._update_session_state(session=workflow_session, session_state=session_state)
 
-    def rename(self, name: str) -> None:
-        """Rename the Workflow and save to storage"""
+        log_debug(f"Workflow Run Start: {self.name}", center=True)
 
-        # -*- Read from storage
-        self.read_from_storage()
-        # -*- Rename Workflow
-        self.name = name
-        # -*- Save to storage
-        self.write_to_storage()
-        # -*- Log Workflow session
-        self.log_workflow_session()
+        # Use simple defaults
+        stream = stream or self.stream or False
+        stream_intermediate_steps = stream_intermediate_steps or self.stream_intermediate_steps or False
 
-    def rename_session(self, session_name: str):
-        """Rename the current session and save to storage"""
+        # Can't have stream_intermediate_steps if stream is False
+        if not stream:
+            stream_intermediate_steps = False
 
-        # -*- Read from storage
-        self.read_from_storage()
-        # -*- Rename session
-        self.session_name = session_name
-        # -*- Save to storage
-        self.write_to_storage()
-        # -*- Log Workflow session
-        self.log_workflow_session()
+        log_debug(f"Stream: {stream}")
+        log_debug(f"Total steps: {self._get_step_count()}")
 
-    def delete_session(self, session_id: str):
-        """Delete the current session and save to storage"""
-        if self.storage is None:
-            return
-        # -*- Delete session
-        self.storage.delete_session(session_id=session_id)
+        # Prepare steps
+        self._prepare_steps()
+
+        # Create workflow run response that will be updated by reference
+        workflow_run_response = WorkflowRunOutput(
+            run_id=run_id,
+            session_id=session_id,
+            workflow_id=self.id,
+            workflow_name=self.name,
+            created_at=int(datetime.now().timestamp()),
+        )
+
+        inputs = WorkflowExecutionInput(
+            input=input,
+            additional_data=additional_data,
+            audio=audio,  # type: ignore
+            images=images,  # type: ignore
+            videos=videos,  # type: ignore
+            files=files,  # type: ignore
+        )
+        log_debug(
+            f"Created pipeline input with session state keys: {list(session_state.keys()) if session_state else 'None'}"
+        )
+
+        self.update_agents_and_teams_session_info()
+
+        if stream:
+            return self._execute_stream(
+                session=workflow_session,
+                execution_input=inputs,  # type: ignore[arg-type]
+                workflow_run_response=workflow_run_response,
+                stream_intermediate_steps=stream_intermediate_steps,
+                session_state=session_state,
+                **kwargs,
+            )
+        else:
+            return self._execute(
+                session=workflow_session,
+                execution_input=inputs,  # type: ignore[arg-type]
+                workflow_run_response=workflow_run_response,
+                session_state=session_state,
+                **kwargs,
+            )
+
+    @overload
+    async def arun(
+        self,
+        input: Optional[Union[str, Dict[str, Any], List[Any], BaseModel, List[Message]]] = None,
+        additional_data: Optional[Dict[str, Any]] = None,
+        user_id: Optional[str] = None,
+        session_id: Optional[str] = None,
+        session_state: Optional[Dict[str, Any]] = None,
+        audio: Optional[List[Audio]] = None,
+        images: Optional[List[Image]] = None,
+        videos: Optional[List[Video]] = None,
+        files: Optional[List[File]] = None,
+        stream: Literal[False] = False,
+        stream_intermediate_steps: Optional[bool] = None,
+        background: Optional[bool] = False,
+        websocket: Optional[WebSocket] = None,
+    ) -> WorkflowRunOutput: ...
+
+    @overload
+    async def arun(
+        self,
+        input: Optional[Union[str, Dict[str, Any], List[Any], BaseModel, List[Message]]] = None,
+        additional_data: Optional[Dict[str, Any]] = None,
+        user_id: Optional[str] = None,
+        session_id: Optional[str] = None,
+        session_state: Optional[Dict[str, Any]] = None,
+        audio: Optional[List[Audio]] = None,
+        images: Optional[List[Image]] = None,
+        videos: Optional[List[Video]] = None,
+        files: Optional[List[File]] = None,
+        stream: Literal[True] = True,
+        stream_intermediate_steps: Optional[bool] = None,
+        background: Optional[bool] = False,
+        websocket: Optional[WebSocket] = None,
+    ) -> AsyncIterator[WorkflowRunOutputEvent]: ...
+
+    async def arun(
+        self,
+        input: Optional[Union[str, Dict[str, Any], List[Any], BaseModel, List[Message]]] = None,
+        additional_data: Optional[Dict[str, Any]] = None,
+        user_id: Optional[str] = None,
+        session_id: Optional[str] = None,
+        session_state: Optional[Dict[str, Any]] = None,
+        audio: Optional[List[Audio]] = None,
+        images: Optional[List[Image]] = None,
+        videos: Optional[List[Video]] = None,
+        files: Optional[List[File]] = None,
+        stream: bool = False,
+        stream_intermediate_steps: Optional[bool] = False,
+        background: Optional[bool] = False,
+        websocket: Optional[WebSocket] = None,
+        **kwargs: Any,
+    ) -> Union[WorkflowRunOutput, AsyncIterator[WorkflowRunOutputEvent]]:
+        """Execute the workflow synchronously with optional streaming"""
+
+        validated_input = self._validate_input(input)
+        if validated_input is not None:
+            input = validated_input
+
+        websocket_handler = None
+        if websocket:
+            from agno.workflow.types import WebSocketHandler
+
+            websocket_handler = WebSocketHandler(websocket=websocket)
+
+        if background:
+            if stream and websocket:
+                # Background + Streaming + WebSocket = Real-time events
+                return await self._arun_background_stream(
+                    input=input,
+                    additional_data=additional_data,
+                    user_id=user_id,
+                    session_id=session_id,
+                    audio=audio,
+                    images=images,
+                    videos=videos,
+                    files=files,
+                    stream_intermediate_steps=stream_intermediate_steps or False,
+                    websocket_handler=websocket_handler,
+                    **kwargs,
+                )
+            elif stream and not websocket:
+                # Background + Streaming but no WebSocket = Not supported
+                raise ValueError("Background streaming execution requires a WebSocket for real-time events")
+            else:
+                # Background + Non-streaming = Polling (existing)
+                return await self._arun_background(
+                    input=input,
+                    additional_data=additional_data,
+                    user_id=user_id,
+                    session_id=session_id,
+                    audio=audio,
+                    images=images,
+                    videos=videos,
+                    files=files,
+                    **kwargs,
+                )
+
+        self._set_debug()
+
+        run_id = str(uuid4())
+
+        self.initialize_workflow()
+        session_id, user_id, session_state = self._initialize_session(
+            session_id=session_id, user_id=user_id, session_state=session_state, run_id=run_id
+        )
+
+        # Read existing session from database
+        workflow_session = self.read_or_create_session(session_id=session_id, user_id=user_id)
+        self._update_metadata(session=workflow_session)
+
+        # Update session state from DB
+        session_state = self._update_session_state(session=workflow_session, session_state=session_state)
+
+        log_debug(f"Async Workflow Run Start: {self.name}", center=True)
+
+        # Use simple defaults
+        stream = stream or self.stream or False
+        stream_intermediate_steps = stream_intermediate_steps or self.stream_intermediate_steps or False
+
+        # Can't have stream_intermediate_steps if stream is False
+        if not stream:
+            stream_intermediate_steps = False
+
+        log_debug(f"Stream: {stream}")
+
+        # Prepare steps
+        self._prepare_steps()
+
+        # Create workflow run response that will be updated by reference
+        workflow_run_response = WorkflowRunOutput(
+            run_id=run_id,
+            session_id=session_id,
+            workflow_id=self.id,
+            workflow_name=self.name,
+            created_at=int(datetime.now().timestamp()),
+        )
+
+        inputs = WorkflowExecutionInput(
+            input=input,
+            additional_data=additional_data,
+            audio=audio,  # type: ignore
+            images=images,  # type: ignore
+            videos=videos,  # type: ignore
+        )
+        log_debug(
+            f"Created async pipeline input with session state keys: {list(session_state.keys()) if session_state else 'None'}"
+        )
+
+        self.update_agents_and_teams_session_info()
+
+        if stream:
+            return self._aexecute_stream(
+                execution_input=inputs,
+                workflow_run_response=workflow_run_response,
+                session=workflow_session,
+                stream_intermediate_steps=stream_intermediate_steps,
+                websocket=websocket,
+                files=files,
+                session_state=session_state,
+                **kwargs,
+            )
+        else:
+            return await self._aexecute(
+                execution_input=inputs,
+                workflow_run_response=workflow_run_response,
+                session=workflow_session,
+                websocket=websocket,
+                files=files,
+                session_state=session_state,
+                **kwargs,
+            )
+
+    def _prepare_steps(self):
+        """Prepare the steps for execution"""
+        if not callable(self.steps) and self.steps is not None:
+            prepared_steps: List[Union[Step, Steps, Loop, Parallel, Condition, Router]] = []
+            for i, step in enumerate(self.steps):  # type: ignore
+                if callable(step) and hasattr(step, "__name__"):
+                    step_name = step.__name__
+                    log_debug(f"Step {i + 1}: Wrapping callable function '{step_name}'")
+                    prepared_steps.append(Step(name=step_name, description="User-defined callable step", executor=step))
+                elif isinstance(step, Agent):
+                    step_name = step.name or f"step_{i + 1}"
+                    log_debug(f"Step {i + 1}: Agent '{step_name}'")
+                    prepared_steps.append(Step(name=step_name, description=step.description, agent=step))
+                elif isinstance(step, Team):
+                    step_name = step.name or f"step_{i + 1}"
+                    log_debug(f"Step {i + 1}: Team '{step_name}' with {len(step.members)} members")
+                    prepared_steps.append(Step(name=step_name, description=step.description, team=step))
+                elif isinstance(step, (Step, Steps, Loop, Parallel, Condition, Router)):
+                    step_type = type(step).__name__
+                    step_name = getattr(step, "name", f"unnamed_{step_type.lower()}")
+                    log_debug(f"Step {i + 1}: {step_type} '{step_name}'")
+                    prepared_steps.append(step)
+                else:
+                    raise ValueError(f"Invalid step type: {type(step).__name__}")
 
-    def deep_copy(self, *, update: Optional[Dict[str, Any]] = None) -> Workflow:
-        """Create and return a deep copy of this Workflow, optionally updating fields.
+            self.steps = prepared_steps  # type: ignore
+            log_debug("Step preparation completed")
+
+    def print_response(
+        self,
+        input: Union[str, Dict[str, Any], List[Any], BaseModel, List[Message]],
+        additional_data: Optional[Dict[str, Any]] = None,
+        user_id: Optional[str] = None,
+        session_id: Optional[str] = None,
+        audio: Optional[List[Audio]] = None,
+        images: Optional[List[Image]] = None,
+        videos: Optional[List[Video]] = None,
+        files: Optional[List[File]] = None,
+        stream: Optional[bool] = None,
+        stream_intermediate_steps: Optional[bool] = None,
+        markdown: bool = True,
+        show_time: bool = True,
+        show_step_details: bool = True,
+        console: Optional[Any] = None,
+        **kwargs: Any,
+    ) -> None:
+        """Print workflow execution with rich formatting and optional streaming
 
         Args:
-            update (Optional[Dict[str, Any]]): Optional dictionary of fields for the new Workflow.
+            input: The main query/input for the workflow
+            additional_data: Attached message data to the input
+            user_id: User ID
+            session_id: Session ID
+            audio: Audio input
+            images: Image input
+            videos: Video input
+            stream: Whether to stream the response content
+            stream_intermediate_steps: Whether to stream intermediate steps
+            markdown: Whether to render content as markdown
+            show_time: Whether to show execution time
+            show_step_details: Whether to show individual step outputs
+            console: Rich console instance (optional)
+        """
 
-        Returns:
-            Workflow: A new Workflow instance.
+        if stream is None:
+            stream = self.stream or False
+
+        if stream_intermediate_steps is None:
+            stream_intermediate_steps = self.stream_intermediate_steps or False
+
+        if stream:
+            print_response_stream(
+                workflow=self,
+                input=input,
+                user_id=user_id,
+                session_id=session_id,
+                additional_data=additional_data,
+                audio=audio,
+                images=images,
+                videos=videos,
+                files=files,
+                stream_intermediate_steps=stream_intermediate_steps,
+                markdown=markdown,
+                show_time=show_time,
+                show_step_details=show_step_details,
+                console=console,
+                **kwargs,
+            )
+        else:
+            print_response(
+                workflow=self,
+                input=input,
+                user_id=user_id,
+                session_id=session_id,
+                additional_data=additional_data,
+                audio=audio,
+                images=images,
+                videos=videos,
+                files=files,
+                markdown=markdown,
+                show_time=show_time,
+                show_step_details=show_step_details,
+                console=console,
+                **kwargs,
+            )
+
+    async def aprint_response(
+        self,
+        input: Union[str, Dict[str, Any], List[Any], BaseModel, List[Message]],
+        additional_data: Optional[Dict[str, Any]] = None,
+        user_id: Optional[str] = None,
+        session_id: Optional[str] = None,
+        audio: Optional[List[Audio]] = None,
+        images: Optional[List[Image]] = None,
+        videos: Optional[List[Video]] = None,
+        files: Optional[List[File]] = None,
+        stream: Optional[bool] = None,
+        stream_intermediate_steps: Optional[bool] = None,
+        markdown: bool = True,
+        show_time: bool = True,
+        show_step_details: bool = True,
+        console: Optional[Any] = None,
+        **kwargs: Any,
+    ) -> None:
+        """Print workflow execution with rich formatting and optional streaming
+
+        Args:
+            input: The main message/input for the workflow
+            additional_data: Attached message data to the input
+            user_id: User ID
+            session_id: Session ID
+            audio: Audio input
+            images: Image input
+            videos: Video input
+            stream_intermediate_steps: Whether to stream intermediate steps
+            stream: Whether to stream the response content
+            markdown: Whether to render content as markdown
+            show_time: Whether to show execution time
+            show_step_details: Whether to show individual step outputs
+            console: Rich console instance (optional)
         """
-        # Extract the fields to set for the new Workflow
-        fields_for_new_workflow: Dict[str, Any] = {}
-
-        for f in fields(self):
-            field_value = getattr(self, f.name)
-            if field_value is not None:
-                if isinstance(field_value, Agent):
-                    fields_for_new_workflow[f.name] = field_value.deep_copy()
-                else:
-                    fields_for_new_workflow[f.name] = self._deep_copy_field(f.name, field_value)
+        if stream is None:
+            stream = self.stream or False
+
+        if stream_intermediate_steps is None:
+            stream_intermediate_steps = self.stream_intermediate_steps or False
+
+        if stream:
+            await aprint_response_stream(
+                workflow=self,
+                input=input,
+                additional_data=additional_data,
+                user_id=user_id,
+                session_id=session_id,
+                audio=audio,
+                images=images,
+                videos=videos,
+                files=files,
+                stream_intermediate_steps=stream_intermediate_steps,
+                markdown=markdown,
+                show_time=show_time,
+                show_step_details=show_step_details,
+                console=console,
+                **kwargs,
+            )
+        else:
+            await aprint_response(
+                workflow=self,
+                input=input,
+                additional_data=additional_data,
+                user_id=user_id,
+                session_id=session_id,
+                audio=audio,
+                images=images,
+                videos=videos,
+                files=files,
+                markdown=markdown,
+                show_time=show_time,
+                show_step_details=show_step_details,
+                console=console,
+                **kwargs,
+            )
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert workflow to dictionary representation"""
 
-        # Update fields if provided
-        if update:
-            fields_for_new_workflow.update(update)
+        def serialize_step(step):
+            step_dict = {
+                "name": step.name if hasattr(step, "name") else f"unnamed_{type(step).__name__.lower()}",
+                "description": step.description if hasattr(step, "description") else "User-defined callable step",
+                "type": STEP_TYPE_MAPPING[type(step)].value,  # type: ignore
+            }
 
-        # Create a new Workflow
-        new_workflow = self.__class__(**fields_for_new_workflow)
-        log_debug(f"Created new {self.__class__.__name__}")
-        return new_workflow
+            # Handle agent/team/tools
+            if hasattr(step, "agent"):
+                step_dict["agent"] = step.agent if hasattr(step, "agent") else None  # type: ignore
+            if hasattr(step, "team"):
+                step_dict["team"] = step.team if hasattr(step, "team") else None  # type: ignore
 
-    def _deep_copy_field(self, field_name: str, field_value: Any) -> Any:
-        """Helper method to deep copy a field based on its type."""
-        from copy import copy, deepcopy
+            # Handle nested steps for Router/Loop
+            if isinstance(step, (Router)):
+                step_dict["steps"] = (
+                    [serialize_step(step) for step in step.choices] if hasattr(step, "choices") else None
+                )
 
-        # For memory, use its deep_copy method
-        if field_name == "memory":
-            return field_value.deep_copy()
+            elif isinstance(step, (Loop, Condition, Steps, Parallel)):
+                step_dict["steps"] = [serialize_step(step) for step in step.steps] if hasattr(step, "steps") else None
 
-        # For compound types, attempt a deep copy
-        if isinstance(field_value, (list, dict, set, Storage)):
-            try:
-                return deepcopy(field_value)
-            except Exception as e:
-                logger.warning(f"Failed to deepcopy field: {field_name} - {e}")
-                try:
-                    return copy(field_value)
-                except Exception as e:
-                    logger.warning(f"Failed to copy field: {field_name} - {e}")
-                    return field_value
+            return step_dict
 
-        # For pydantic models, attempt a model_copy
-        if isinstance(field_value, BaseModel):
-            try:
-                return field_value.model_copy(deep=True)
-            except Exception as e:
-                logger.warning(f"Failed to deepcopy field: {field_name} - {e}")
-                try:
-                    return field_value.model_copy(deep=False)
-                except Exception as e:
-                    logger.warning(f"Failed to copy field: {field_name} - {e}")
-                    return field_value
+        if self.steps is None or callable(self.steps):
+            steps_list = []
+        elif isinstance(self.steps, Steps):
+            steps_list = self.steps.steps
+        else:
+            steps_list = self.steps
+
+        return {
+            "name": self.name,
+            "workflow_id": self.id,
+            "description": self.description,
+            "steps": [serialize_step(s) for s in steps_list],
+            "session_id": self.session_id,
+        }
+
+    def _calculate_session_metrics_from_workflow_metrics(self, workflow_metrics: WorkflowMetrics) -> Metrics:
+        """Calculate session metrics by aggregating all step metrics from workflow metrics"""
+        session_metrics = Metrics()
+
+        # Aggregate metrics from all steps
+        for step_name, step_metrics in workflow_metrics.steps.items():
+            if step_metrics.metrics:
+                session_metrics += step_metrics.metrics
+
+        session_metrics.time_to_first_token = None
+
+        return session_metrics
+
+    def _get_session_metrics(self, session: WorkflowSession) -> Metrics:
+        """Get existing session metrics from the database"""
+        if session.session_data and "session_metrics" in session.session_data:
+            session_metrics_from_db = session.session_data.get("session_metrics")
+            if session_metrics_from_db is not None:
+                if isinstance(session_metrics_from_db, dict):
+                    return Metrics(**session_metrics_from_db)
+                elif isinstance(session_metrics_from_db, Metrics):
+                    return session_metrics_from_db
+        return Metrics()
+
+    def _update_session_metrics(self, session: WorkflowSession, workflow_run_response: WorkflowRunOutput):
+        """Calculate and update session metrics"""
+        # Get existing session metrics
+        session_metrics = self._get_session_metrics(session=session)
+
+        # If workflow has metrics, convert and add them to session metrics
+        if workflow_run_response.metrics:
+            run_session_metrics = self._calculate_session_metrics_from_workflow_metrics(workflow_run_response.metrics)
+
+            session_metrics += run_session_metrics
+
+        session_metrics.time_to_first_token = None
+
+        # Store updated session metrics - CONVERT TO DICT FOR JSON SERIALIZATION
+        if not session.session_data:
+            session.session_data = {}
+        session.session_data["session_metrics"] = session_metrics.to_dict()
+
+    def get_session_metrics(self, session_id: Optional[str] = None) -> Optional[Metrics]:
+        """Get the session metrics for the given session ID and user ID."""
+        session_id = session_id or self.session_id
+        if session_id is None:
+            raise Exception("Session ID is required")
+
+        session = self.get_session(session_id=session_id)
+        if session is None:
+            raise Exception("Session not found")
+
+        return self._get_session_metrics(session=session)
+
+    def update_agents_and_teams_session_info(self):
+        """Update agents and teams with workflow session information"""
+        log_debug("Updating agents and teams with session information")
+        # Initialize steps - only if steps is iterable (not callable)
+        if self.steps and not callable(self.steps):
+            steps_list = self.steps.steps if isinstance(self.steps, Steps) else self.steps
+            for step in steps_list:
+                # TODO: Handle properly steps inside other primitives
+                if isinstance(step, Step):
+                    active_executor = step.active_executor
+
+                    if hasattr(active_executor, "workflow_id"):
+                        active_executor.workflow_id = self.id
+
+                    # If it's a team, update all members
+                    if hasattr(active_executor, "members"):
+                        for member in active_executor.members:
+                            if hasattr(member, "workflow_id"):
+                                member.workflow_id = self.id
+
+    ###########################################################################
+    # Telemetry functions
+    ###########################################################################
+
+    def _get_telemetry_data(self) -> Dict[str, Any]:
+        """Get the telemetry data for the workflow"""
+        return {
+            "workflow_id": self.id,
+            "db_type": self.db.__class__.__name__ if self.db else None,
+            "has_input_schema": self.input_schema is not None,
+        }
+
+    def _log_workflow_telemetry(self, session_id: str, run_id: Optional[str] = None) -> None:
+        """Send a telemetry event to the API for a created Workflow run"""
+
+        self._set_telemetry()
+        if not self.telemetry:
+            return
+
+        from agno.api.workflow import WorkflowRunCreate, create_workflow_run
 
-        # For other types, return as is
-        return field_value
+        try:
+            create_workflow_run(
+                workflow=WorkflowRunCreate(session_id=session_id, run_id=run_id, data=self._get_telemetry_data()),
+            )
+        except Exception as e:
+            log_debug(f"Could not create Workflow run telemetry event: {e}")
+
+    async def _alog_workflow_telemetry(self, session_id: str, run_id: Optional[str] = None) -> None:
+        """Send a telemetry event to the API for a created Workflow async run"""
+
+        self._set_telemetry()
+        if not self.telemetry:
+            return
+
+        from agno.api.workflow import WorkflowRunCreate, acreate_workflow_run
+
+        try:
+            await acreate_workflow_run(
+                workflow=WorkflowRunCreate(session_id=session_id, run_id=run_id, data=self._get_telemetry_data())
+            )
+        except Exception as e:
+            log_debug(f"Could not create Workflow run telemetry event: {e}")