agno 2.1.10__py3-none-any.whl → 2.2.0__py3-none-any.whl

agno/team/team.py

@@ -10,7 +10,6 @@ from typing import (
     Any,
     AsyncIterator,
     Callable,
-    Coroutine,
     Dict,
     Iterator,
     List,
@@ -59,15 +58,28 @@ from agno.run.cancel import (
 )
 from agno.run.messages import RunMessages
 from agno.run.team import TeamRunEvent, TeamRunInput, TeamRunOutput, TeamRunOutputEvent
-from agno.session import SessionSummaryManager, TeamSession
+from agno.session import SessionSummaryManager, TeamSession, WorkflowSession
 from agno.tools import Toolkit
 from agno.tools.function import Function
+from agno.utils.agent import (
+    await_for_background_tasks,
+    await_for_background_tasks_stream,
+    collect_joint_audios,
+    collect_joint_files,
+    collect_joint_images,
+    collect_joint_videos,
+    scrub_history_messages_from_run_output,
+    scrub_media_from_run_output,
+    scrub_tool_results_from_run_output,
+    wait_for_background_tasks,
+    wait_for_background_tasks_stream,
+)
 from agno.utils.common import is_typed_dict, validate_typed_dict
 from agno.utils.events import (
-    create_team_memory_update_completed_event,
-    create_team_memory_update_started_event,
     create_team_parser_model_response_completed_event,
     create_team_parser_model_response_started_event,
+    create_team_post_hook_completed_event,
+    create_team_post_hook_started_event,
     create_team_pre_hook_completed_event,
     create_team_pre_hook_started_event,
     create_team_reasoning_completed_event,
@@ -75,11 +87,15 @@ from agno.utils.events import (
     create_team_reasoning_step_event,
     create_team_run_cancelled_event,
     create_team_run_completed_event,
+    create_team_run_content_completed_event,
     create_team_run_error_event,
     create_team_run_output_content_event,
     create_team_run_started_event,
+    create_team_session_summary_completed_event,
+    create_team_session_summary_started_event,
     create_team_tool_call_completed_event,
     create_team_tool_call_started_event,
+    handle_event,
 )
 from agno.utils.hooks import filter_hook_args, normalize_hooks
 from agno.utils.knowledge import get_agentic_or_user_search_filters
@@ -131,15 +147,22 @@ class Team:
     model: Optional[Model] = None
 
     # --- Team settings ---
-    # Name of the team
-    name: Optional[str] = None
     # Team UUID (autogenerated if not set)
     id: Optional[str] = None
-    # If this team is part of a team itself, this is the role of the team
-    parent_team_id: Optional[str] = None
+    # Name of the team
+    name: Optional[str] = None
     # If this team is part of a team itself, this is the role of the team
     role: Optional[str] = None
 
+    # --- If this Team is part of a team itself ---
+    # If this team is part of a team itself, this is the ID of the parent team. This is set automatically.
+    parent_team_id: Optional[str] = None
+
+    # --- If this Team is part of a workflow ---
+    # Optional workflow ID. Indicates this team is part of a workflow. This is set automatically.
+    workflow_id: Optional[str] = None
+
+    # --- Team execution settings ---
     # If True, the team leader won't process responses from the members and instead will return them directly
     # Should not be used in combination with delegate_task_to_all_members
     respond_directly: bool = False
@@ -148,10 +171,6 @@ class Team:
     # Set to false if you want to send the run input directly to the member agents
     determine_input_for_members: bool = True
 
-    # --- If this Team is part of a workflow ---
-    # Optional workflow ID. Indicates this team is part of a workflow.
-    workflow_id: Optional[str] = None
-
     # --- User settings ---
     # Default user ID for this team
     user_id: Optional[str] = None
@@ -170,13 +189,28 @@ class Team:
     # If True, cache the current Team session in memory for faster access
     cache_session: bool = False
 
-    # If True, allow searching through previous sessions
+    # --- Team history settings ---
+    # add_history_to_context=true adds messages from the chat history to the messages list sent to the Model. This only applies to the team leader, not the members.
+    add_history_to_context: bool = False
+    # Number of historical runs to include in the messages
+    num_history_runs: int = 3
+
+    # Add this flag to control if the workflow should send the team history to the members. This means sending the team-level history to the members, not the agent-level history.
+    add_team_history_to_members: bool = False
+    # Number of historical runs to include in the messages sent to the members
+    num_team_history_runs: int = 3
+    # If True, send all member interactions (request/response) during the current run to members that have been delegated a task to
+    share_member_interactions: bool = False
+
+    # If True, adds a tool to allow searching through previous sessions
     search_session_history: Optional[bool] = False
     # Number of past sessions to include in the search
     num_history_sessions: Optional[int] = None
 
-    # If True, resolve the session_state, dependencies, and metadata in the user and system messages
-    resolve_in_context: bool = True
+    # If True, adds a tool to allow the team to read the team history (this is deprecated and will be removed in a future version)
+    read_team_history: bool = False
+    # If True, adds a tool to allow the team to read the chat history
+    read_chat_history: bool = False
 
     # --- System message settings ---
     # A description of the Team that is added to the start of the system message.
@@ -206,6 +240,9 @@ class Team:
     # Role for the system message
     system_message_role: str = "system"
 
+    # If True, resolve the session_state, dependencies, and metadata in the user and system messages
+    resolve_in_context: bool = True
+
     # --- Extra Messages ---
     # A list of extra messages added after the system message and before the user message.
     # Use these for few-shot learning or to provide additional context to the Model.
@@ -244,17 +281,12 @@ class Team:
     references_format: Literal["json", "yaml"] = "json"
 
     # --- Tools ---
-    # If True, send all previous member interactions to members
-    share_member_interactions: bool = False
     # If True, add a tool to get information about the team members
     get_member_information_tool: bool = False
     # Add a tool to search the knowledge base (aka Agentic RAG)
     # Only added if knowledge is provided.
     search_knowledge: bool = True
 
-    # If True, read the team history
-    read_team_history: bool = False
-
     # If False, media (images, videos, audio, files) is only available to tools and not sent to the LLM
     send_media_to_model: bool = True
     # If True, store media in run output
@@ -322,12 +354,6 @@ class Team:
     # If True, the team adds session summaries to the context
     add_session_summary_to_context: Optional[bool] = None
 
-    # --- Team History ---
-    # add_history_to_context=true adds messages from the chat history to the messages list sent to the Model.
-    add_history_to_context: bool = False
-    # Number of historical runs to include in the messages
-    num_history_runs: int = 3
-
     # --- Team Storage ---
     # Metadata stored with this team
     metadata: Optional[Dict[str, Any]] = None
@@ -342,8 +368,10 @@ class Team:
     # --- Team Streaming ---
     # Stream the response from the Team
     stream: Optional[bool] = None
-    # Stream the intermediate steps from the Team
-    stream_intermediate_steps: bool = False
+    # Stream the intermediate steps from the Agent
+    stream_events: Optional[bool] = None
+    # [Deprecated] Stream the intermediate steps from the Agent
+    stream_intermediate_steps: Optional[bool] = None
     # Stream the member events from the Team
     stream_member_events: bool = True
 
@@ -393,6 +421,10 @@ class Team:
         overwrite_db_session_state: bool = False,
         resolve_in_context: bool = True,
         cache_session: bool = False,
+        add_history_to_context: bool = False,
+        num_history_runs: int = 3,
+        add_team_history_to_members: bool = False,
+        num_team_history_runs: int = 3,
         search_session_history: Optional[bool] = False,
         num_history_sessions: Optional[int] = None,
         description: Optional[str] = None,
@@ -421,6 +453,7 @@ class Team:
         get_member_information_tool: bool = False,
         search_knowledge: bool = True,
         read_team_history: bool = False,
+        read_chat_history: bool = False,
         store_media: bool = True,
         store_tool_messages: bool = True,
         store_history_messages: bool = True,
@@ -447,8 +480,6 @@ class Team:
         enable_session_summaries: bool = False,
         session_summary_manager: Optional[SessionSummaryManager] = None,
         add_session_summary_to_context: Optional[bool] = None,
-        add_history_to_context: bool = False,
-        num_history_runs: int = 3,
         metadata: Optional[Dict[str, Any]] = None,
         reasoning: bool = False,
         reasoning_model: Optional[Model] = None,
@@ -456,7 +487,8 @@ class Team:
         reasoning_min_steps: int = 1,
         reasoning_max_steps: int = 10,
         stream: Optional[bool] = None,
-        stream_intermediate_steps: bool = False,
+        stream_events: Optional[bool] = None,
+        stream_intermediate_steps: Optional[bool] = None,
         store_events: bool = False,
         events_to_skip: Optional[List[Union[RunEvent, TeamRunEvent]]] = None,
         store_member_responses: bool = False,
@@ -490,6 +522,10 @@ class Team:
         self.resolve_in_context = resolve_in_context
         self.cache_session = cache_session
 
+        self.add_history_to_context = add_history_to_context
+        self.num_history_runs = num_history_runs
+        self.add_team_history_to_members = add_team_history_to_members
+        self.num_team_history_runs = num_team_history_runs
         self.search_session_history = search_session_history
         self.num_history_sessions = num_history_sessions
 
@@ -521,7 +557,7 @@ class Team:
         self.share_member_interactions = share_member_interactions
         self.get_member_information_tool = get_member_information_tool
         self.search_knowledge = search_knowledge
-        self.read_team_history = read_team_history
+        self.read_chat_history = read_chat_history or read_team_history
 
         self.store_media = store_media
         self.store_tool_messages = store_tool_messages
@@ -555,15 +591,8 @@ class Team:
         self.enable_session_summaries = enable_session_summaries
         self.session_summary_manager = session_summary_manager
         self.add_session_summary_to_context = add_session_summary_to_context
-        self.add_history_to_context = add_history_to_context
-        self.num_history_runs = num_history_runs
         self.metadata = metadata
 
-        if add_history_to_context and not db:
-            log_warning(
-                "add_history_to_context is True, but no database has been assigned to the agent. History will not be added to the context."
-            )
-
         self.reasoning = reasoning
         self.reasoning_model = reasoning_model
         self.reasoning_agent = reasoning_agent
@@ -571,7 +600,7 @@ class Team:
         self.reasoning_max_steps = reasoning_max_steps
 
         self.stream = stream
-        self.stream_intermediate_steps = stream_intermediate_steps
+        self.stream_events = stream_events or stream_intermediate_steps
         self.store_events = store_events
         self.store_member_responses = store_member_responses
 
@@ -620,6 +649,22 @@ class Team:
 
         self._hooks_normalised = False
 
+        # Lazy-initialized shared thread pool executor for background tasks (memory, cultural knowledge, etc.)
+        self._background_executor: Optional[Any] = None
+
+    @property
+    def background_executor(self) -> Any:
+        """Lazy initialization of shared thread pool executor for background tasks.
+
+        Handles both memory creation and cultural knowledge updates concurrently.
+        Initialized only on first use (runtime, not instantiation) and reused across runs.
+        """
+        if self._background_executor is None:
+            from concurrent.futures import ThreadPoolExecutor
+
+            self._background_executor = ThreadPoolExecutor(max_workers=3, thread_name_prefix="agno-bg")
+        return self._background_executor
+
     @property
     def should_parse_structured_output(self) -> bool:
         return self.output_schema is not None and self.parse_response and self.parser_model is None
@@ -759,11 +804,11 @@ class Team:
 
     def _initialize_session(
         self,
-        run_id: str,
-        user_id: Optional[str] = None,
         session_id: Optional[str] = None,
-        session_state: Optional[Dict[str, Any]] = None,
-    ) -> Tuple[str, Optional[str], Dict[str, Any]]:
+        user_id: Optional[str] = None,
+    ) -> Tuple[str, Optional[str]]:
+        """Initialize the session for the team."""
+
         if session_id is None:
             if self.session_id:
                 session_id = self.session_id
@@ -775,30 +820,26 @@ class Team:
         log_debug(f"Session ID: {session_id}", center=True)
 
         # Use the default user_id when necessary
-        if user_id is None:
+        if user_id is None or user_id == "":
             user_id = self.user_id
 
-        # Determine the session_state with proper precedence
-        if session_state is None:
-            session_state = self.session_state or {}
-        else:
-            # If run session_state is provided, merge agent defaults under it
-            # This ensures run state takes precedence over agent defaults
-            if self.session_state:
-                from agno.utils.merge_dict import merge_dictionaries
-
-                base_state = self.session_state.copy()
-                merge_dictionaries(base_state, session_state)
-                session_state.clear()
-                session_state.update(base_state)
+        return session_id, user_id
 
-        if user_id is not None:
+    def _initialize_session_state(
+        self,
+        session_state: Dict[str, Any],
+        user_id: Optional[str] = None,
+        session_id: Optional[str] = None,
+        run_id: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """Initialize the session state for the team."""
+        if user_id:
             session_state["current_user_id"] = user_id
         if session_id is not None:
             session_state["current_session_id"] = session_id
-        session_state["current_run_id"] = run_id
-
-        return session_id, user_id, session_state  # type: ignore
+        if run_id is not None:
+            session_state["current_run_id"] = run_id
+        return session_state
 
     def _has_async_db(self) -> bool:
         """Return True if the db the team is equipped with is an Async implementation"""
@@ -810,7 +851,7 @@ class Team:
 
         if self.delegate_task_to_all_members and self.respond_directly:
             log_warning(
-                "delegate_task_to_all_members and respond_directly are both enabled. The task will be delegated to all members."
+                "`delegate_task_to_all_members` and `respond_directly` are both enabled. The task will be delegated to all members, but `respond_directly` will be disabled."
             )
             self.respond_directly = False
 
@@ -887,11 +928,13 @@ class Team:
         all_args.update(kwargs)
 
         for i, hook in enumerate(hooks):
-            yield self._handle_event(
+            yield handle_event(  # type: ignore
                 run_response=run_response,
                 event=create_team_pre_hook_started_event(
                     from_run_response=run_response, run_input=run_input, pre_hook_name=hook.__name__
                 ),
+                events_to_skip=self.events_to_skip,
+                store_events=self.store_events,
             )
             try:
                 # Filter arguments to only include those that the hook accepts
@@ -899,11 +942,13 @@ class Team:
 
                 hook(**filtered_args)
 
-                yield self._handle_event(
+                yield handle_event(  # type: ignore
                     run_response=run_response,
                     event=create_team_pre_hook_completed_event(
                         from_run_response=run_response, run_input=run_input, pre_hook_name=hook.__name__
                     ),
+                    events_to_skip=self.events_to_skip,
+                    store_events=self.store_events,
                 )
 
             except (InputCheckError, OutputCheckError) as e:
@@ -949,11 +994,13 @@ class Team:
         all_args.update(kwargs)
 
         for i, hook in enumerate(hooks):
-            yield self._handle_event(
+            yield handle_event(  # type: ignore
                 run_response=run_response,
                 event=create_team_pre_hook_started_event(
                     from_run_response=run_response, run_input=run_input, pre_hook_name=hook.__name__
                 ),
+                events_to_skip=self.events_to_skip,
+                store_events=self.store_events,
             )
             try:
                 # Filter arguments to only include those that the hook accepts
@@ -965,11 +1012,13 @@ class Team:
                     # Synchronous function
                     hook(**filtered_args)
 
-                yield self._handle_event(
+                yield handle_event(  # type: ignore
                     run_response=run_response,
                     event=create_team_pre_hook_completed_event(
                         from_run_response=run_response, run_input=run_input, pre_hook_name=hook.__name__
                     ),
+                    events_to_skip=self.events_to_skip,
+                    store_events=self.store_events,
                 )
 
             except (InputCheckError, OutputCheckError) as e:
@@ -995,7 +1044,7 @@ class Team:
         user_id: Optional[str] = None,
         debug_mode: Optional[bool] = None,
         **kwargs: Any,
-    ) -> None:
+    ) -> Iterator[TeamRunOutputEvent]:
         """Execute multiple post-hook functions in succession."""
         if hooks is None:
             return
@@ -1014,12 +1063,31 @@ class Team:
         all_args.update(kwargs)
 
         for i, hook in enumerate(hooks):
+            yield handle_event(  # type: ignore
+                run_response=run_output,
+                event=create_team_post_hook_started_event(  # type: ignore
+                    from_run_response=run_output,
+                    post_hook_name=hook.__name__,
+                ),
+                events_to_skip=self.events_to_skip,
+                store_events=self.store_events,
+            )
             try:
                 # Filter arguments to only include those that the hook accepts
                 filtered_args = filter_hook_args(hook, all_args)
 
                 hook(**filtered_args)
 
+                yield handle_event(  # type: ignore
+                    run_response=run_output,
+                    event=create_team_post_hook_completed_event(  # type: ignore
+                        from_run_response=run_output,
+                        post_hook_name=hook.__name__,
+                    ),
+                    events_to_skip=self.events_to_skip,
+                    store_events=self.store_events,
+                )
+
             except (InputCheckError, OutputCheckError) as e:
                 raise e
             except Exception as e:
@@ -1037,7 +1105,7 @@ class Team:
         metadata: Optional[Dict[str, Any]] = None,
         debug_mode: Optional[bool] = None,
         **kwargs: Any,
-    ) -> None:
+    ) -> AsyncIterator[TeamRunOutputEvent]:
         """Execute multiple post-hook functions in succession (async version)."""
         if hooks is None:
             return
@@ -1056,6 +1124,15 @@ class Team:
         all_args.update(kwargs)
 
         for i, hook in enumerate(hooks):
+            yield handle_event(  # type: ignore
+                run_response=run_output,
+                event=create_team_post_hook_started_event(  # type: ignore
+                    from_run_response=run_output,
+                    post_hook_name=hook.__name__,
+                ),
+                events_to_skip=self.events_to_skip,
+                store_events=self.store_events,
+            )
             try:
                 # Filter arguments to only include those that the hook accepts
                 filtered_args = filter_hook_args(hook, all_args)
@@ -1065,6 +1142,15 @@ class Team:
                 else:
                     hook(**filtered_args)
 
+                yield handle_event(  # type: ignore
+                    run_response=run_output,
+                    event=create_team_post_hook_completed_event(  # type: ignore
+                        from_run_response=run_output,
+                        post_hook_name=hook.__name__,
+                    ),
+                    events_to_skip=self.events_to_skip,
+                    store_events=self.store_events,
+                )
             except (InputCheckError, OutputCheckError) as e:
                 raise e
             except Exception as e:
@@ -1091,15 +1177,18 @@ class Team:
 
         Steps:
         1. Execute pre-hooks
-        2. Get run messages
-        3. Reason about the task(s) if reasoning is enabled
-        4. Get a response from the model
-        5. Update TeamRunOutput
-        6. Execute post-hooks
-        7. Add RunOutput to Team Session
-        8. Calculate session metrics
-        9. Update Team Memory
-        10. Save session to storage
+        2. Determine tools for model
+        3. Prepare run messages
+        4. Start memory creation in background thread
+        5. Reason about the task if reasoning is enabled
+        6. Get a response from the model
+        7. Update TeamRunOutput with the model response
+        8. Store media if enabled
+        9. Convert response to structured format
+        10. Execute post-hooks
+        11. Wait for background memory creation
+        12. Create session summary
+        13. Cleanup and store (scrub, stop timer, add to session, calculate metrics, save session)
         """
 
         # Register run for cancellation tracking
@@ -1125,6 +1214,7 @@ class Team:
             # Consume the generator without yielding
             deque(pre_hook_iterator, maxlen=0)
 
+        # 2. Determine tools for model
         # Initialize team run context
         team_run_context: Dict[str, Any] = {}
 
@@ -1150,7 +1240,7 @@ class Team:
             metadata=metadata,
         )
 
-        # 2. Prepare run messages
+        # 3. Prepare run messages
         run_messages: RunMessages = self._get_run_messages(
             run_response=run_response,
             session=session,
@@ -1174,95 +1264,109 @@ class Team:
 
         log_debug(f"Team Run Start: {run_response.run_id}", center=True)
 
-        # 3. Reason about the task(s) if reasoning is enabled
-        self._handle_reasoning(run_response=run_response, run_messages=run_messages)
+        # 4. Start memory creation in background thread
+        memory_future = None
+        if run_messages.user_message is not None and self.memory_manager is not None and not self.enable_agentic_memory:
+            log_debug("Starting memory creation in background thread.")
+            memory_future = self.background_executor.submit(
+                self._make_memories, run_messages=run_messages, user_id=user_id
+            )
 
-        # Check for cancellation before model call
-        raise_if_cancelled(run_response.run_id)  # type: ignore
+        try:
+            raise_if_cancelled(run_response.run_id)  # type: ignore
 
-        # 4. Get the model response for the team leader
-        self.model = cast(Model, self.model)
-        model_response: ModelResponse = self.model.response(
-            messages=run_messages.messages,
-            response_format=response_format,
-            tools=self._tools_for_model,
-            functions=self._functions_for_model,
-            tool_choice=self.tool_choice,
-            tool_call_limit=self.tool_call_limit,
-            send_media_to_model=self.send_media_to_model,
-        )
+            # 5. Reason about the task if reasoning is enabled
+            self._handle_reasoning(run_response=run_response, run_messages=run_messages)
 
-        # Check for cancellation after model call
-        raise_if_cancelled(run_response.run_id)  # type: ignore
+            # Check for cancellation before model call
+            raise_if_cancelled(run_response.run_id)  # type: ignore
 
-        # If an output model is provided, generate output using the output model
-        self._parse_response_with_output_model(model_response, run_messages)
+            # 6. Get the model response for the team leader
+            self.model = cast(Model, self.model)
+            model_response: ModelResponse = self.model.response(
+                messages=run_messages.messages,
+                response_format=response_format,
+                tools=self._tools_for_model,
+                functions=self._functions_for_model,
+                tool_choice=self.tool_choice,
+                tool_call_limit=self.tool_call_limit,
+                send_media_to_model=self.send_media_to_model,
+            )
 
-        # If a parser model is provided, structure the response separately
-        self._parse_response_with_parser_model(model_response, run_messages)
+            # Check for cancellation after model call
+            raise_if_cancelled(run_response.run_id)  # type: ignore
 
-        #  5. Update TeamRunOutput
-        self._update_run_response(model_response=model_response, run_response=run_response, run_messages=run_messages)
+            # If an output model is provided, generate output using the output model
+            self._parse_response_with_output_model(model_response, run_messages)
 
-        if self.store_media:
-            self._store_media(run_response, model_response)
-        else:
-            self._scrub_media_from_run_output(run_response)
-
-        # Parse team response model
-        self._convert_response_to_structured_format(run_response=run_response)
+            # If a parser model is provided, structure the response separately
+            self._parse_response_with_parser_model(model_response, run_messages)
 
-        # 6. Execute post-hooks after output is generated but before response is returned
-        if self.post_hooks is not None:
-            self._execute_post_hooks(
-                hooks=self.post_hooks,  # type: ignore
-                run_output=run_response,
-                session=session,
-                session_state=session_state,
-                dependencies=dependencies,
-                metadata=metadata,
-                user_id=user_id,
-                debug_mode=debug_mode,
-                **kwargs,
+            # 7. Update TeamRunOutput with the model response
+            self._update_run_response(
+                model_response=model_response, run_response=run_response, run_messages=run_messages
             )
 
-        run_response.status = RunStatus.completed
+            # 8. Store media if enabled
+            if self.store_media:
+                self._store_media(run_response, model_response)
 
-        # Set the run duration
-        if run_response.metrics:
-            run_response.metrics.stop_timer()
+            # 9. Convert response to structured format
+            self._convert_response_to_structured_format(run_response=run_response)
 
-        # 7. Add the RunOutput to Team Session
-        session.upsert_run(run_response=run_response)
+            # 10. Execute post-hooks after output is generated but before response is returned
+            if self.post_hooks is not None:
+                iterator = self._execute_post_hooks(
+                    hooks=self.post_hooks,  # type: ignore
+                    run_output=run_response,
+                    session=session,
+                    user_id=user_id,
+                    debug_mode=debug_mode,
+                    **kwargs,
+                )
+                deque(iterator, maxlen=0)
+            raise_if_cancelled(run_response.run_id)  # type: ignore
 
-        # 8. Calculate session metrics
-        self._update_session_metrics(session=session)
+            # 11. Wait for background memory creation
+            wait_for_background_tasks(memory_future=memory_future)
 
-        # 9. Update Team Memory
-        response_iterator = self._make_memories_and_summaries(
-            run_response=run_response,
-            run_messages=run_messages,
-            session=session,
-            user_id=user_id,
-        )
-        deque(response_iterator, maxlen=0)
+            raise_if_cancelled(run_response.run_id)  # type: ignore
+
+            # 12. Create session summary
+            if self.session_summary_manager is not None:
+                # Upsert the RunOutput to Team Session before creating the session summary
+                session.upsert_run(run_response=run_response)
+                try:
+                    self.session_summary_manager.create_session_summary(session=session)
+                except Exception as e:
+                    log_warning(f"Error in session summary creation: {str(e)}")
+
+            raise_if_cancelled(run_response.run_id)  # type: ignore
 
-        # 10. Scrub the stored run based on storage flags
-        if self._scrub_run_output_for_storage(run_response):
-            session.upsert_run(run_response=run_response)
+            # Set the run status to completed
+            run_response.status = RunStatus.completed
 
-        # 11. Save session to storage
-        self.save_session(session=session)
+            # 13. Cleanup and store the run response
+            self._cleanup_and_store(run_response=run_response, session=session)
 
-        # Log Team Telemetry
-        self._log_team_telemetry(session_id=session.session_id, run_id=run_response.run_id)
+            # Log Team Telemetry
+            self._log_team_telemetry(session_id=session.session_id, run_id=run_response.run_id)
+
+            log_debug(f"Team Run End: {run_response.run_id}", center=True, symbol="*")
 
-        log_debug(f"Team Run End: {run_response.run_id}", center=True, symbol="*")
+            return run_response
 
-        # Always clean up the run tracking
-        cleanup_run(run_response.run_id)  # type: ignore
+        except RunCancelledException as e:
+            # Handle run cancellation during streaming
+            log_info(f"Team run {run_response.run_id} was cancelled")
+            run_response.status = RunStatus.cancelled
+            run_response.content = str(e)
 
-        return run_response
+            # Add the RunOutput to Team Session even when cancelled
+            self._cleanup_and_store(run_response=run_response, session=session)
+            return run_response
+        finally:
+            cleanup_run(run_response.run_id)  # type: ignore
 
     def _run_stream(
         self,
@@ -1277,7 +1381,7 @@ class Team:
         metadata: Optional[Dict[str, Any]] = None,
         dependencies: Optional[Dict[str, Any]] = None,
         response_format: Optional[Union[Dict, Type[BaseModel]]] = None,
-        stream_intermediate_steps: bool = False,
+        stream_events: bool = False,
         yield_run_response: bool = False,
         debug_mode: Optional[bool] = None,
         **kwargs: Any,
@@ -1286,14 +1390,15 @@ class Team:
 
         Steps:
         1. Execute pre-hooks
-        2. Prepare run messages
-        3. Reason about the task(s) if reasoning is enabled
-        4. Get a response from the model
-        5. Add the run to Team Session
-        6. Update Team Memory
-        7. Create the run completed event
-        8. Calculate session metrics
-        9. Save session to storage
+        2. Determine tools for model
+        3. Prepare run messages
+        4. Start memory creation in background thread
+        5. Reason about the task if reasoning is enabled
+        6. Get a response from the model
+        7. Parse response with parser model if provided
+        8. Wait for background memory creation
+        9. Create session summary
+        10. Cleanup and store (scrub, add to session, calculate metrics, save session)
         """
         # Register run for cancellation tracking
         register_run(run_response.run_id)  # type: ignore
@@ -1318,6 +1423,7 @@ class Team:
             for pre_hook_event in pre_hook_iterator:
                 yield pre_hook_event
 
+        # 2. Determine tools for model
         # Initialize team run context
         team_run_context: Dict[str, Any] = {}
 
@@ -1343,7 +1449,7 @@ class Team:
             metadata=metadata,
         )
 
-        # 2. Prepare run messages
+        # 3. Prepare run messages
         run_messages: RunMessages = self._get_run_messages(
             run_response=run_response,
             session=session,
@@ -1367,28 +1473,44 @@ class Team:
 
         log_debug(f"Team Run Start: {run_response.run_id}", center=True)
 
+        # 4. Start memory creation in background thread
+        memory_future = None
+        if run_messages.user_message is not None and self.memory_manager is not None and not self.enable_agentic_memory:
+            log_debug("Starting memory creation in background thread.")
+            memory_future = self.background_executor.submit(
+                self._make_memories, run_messages=run_messages, user_id=user_id
+            )
+
         try:
             # Start the Run by yielding a RunStarted event
-            if stream_intermediate_steps:
-                yield self._handle_event(create_team_run_started_event(run_response), run_response)
+            if stream_events:
+                yield handle_event(  # type: ignore
+                    create_team_run_started_event(run_response),
+                    run_response,
+                    events_to_skip=self.events_to_skip,
+                    store_events=self.store_events,
+                )
+
+            raise_if_cancelled(run_response.run_id)  # type: ignore
 
-            # 3. Reason about the task(s) if reasoning is enabled
+            # 5. Reason about the task if reasoning is enabled
             yield from self._handle_reasoning_stream(
                 run_response=run_response,
                 run_messages=run_messages,
+                stream_events=stream_events,
             )
 
             # Check for cancellation before model processing
             raise_if_cancelled(run_response.run_id)  # type: ignore
 
-            # 4. Get a response from the model
+            # 6. Get a response from the model
             if self.output_model is None:
                 for event in self._handle_model_response_stream(
                     session=session,
                     run_response=run_response,
                     run_messages=run_messages,
                     response_format=response_format,
-                    stream_intermediate_steps=stream_intermediate_steps,
+                    stream_events=stream_events,
                 ):
                     raise_if_cancelled(run_response.run_id)  # type: ignore
                     yield event
@@ -1398,13 +1520,13 @@ class Team:
                     run_response=run_response,
                     run_messages=run_messages,
                     response_format=response_format,
-                    stream_intermediate_steps=stream_intermediate_steps,
+                    stream_events=stream_events,
                 ):
                     raise_if_cancelled(run_response.run_id)  # type: ignore
                     from agno.run.team import IntermediateRunContentEvent, RunContentEvent
 
                     if isinstance(event, RunContentEvent):
-                        if stream_intermediate_steps:
+                        if stream_events:
                             yield IntermediateRunContentEvent(
                                 content=event.content,
                                 content_type=event.content_type,
@@ -1416,7 +1538,7 @@ class Team:
                     session=session,
                     run_response=run_response,
                     run_messages=run_messages,
-                    stream_intermediate_steps=stream_intermediate_steps,
+                    stream_events=stream_events,
                 ):
                     raise_if_cancelled(run_response.run_id)  # type: ignore
                     yield event
@@ -1424,14 +1546,22 @@ class Team:
             # Check for cancellation after model processing
             raise_if_cancelled(run_response.run_id)  # type: ignore
 
-            # If a parser model is provided, structure the response separately
+            # 7. Parse response with parser model if provided
             yield from self._parse_response_with_parser_model_stream(
-                session=session, run_response=run_response, stream_intermediate_steps=stream_intermediate_steps
+                session=session, run_response=run_response, stream_events=stream_events
             )
 
+            # Yield RunContentCompletedEvent
+            if stream_events:
+                yield handle_event(  # type: ignore
+                    create_team_run_content_completed_event(from_run_response=run_response),
+                    run_response,
+                    events_to_skip=self.events_to_skip,
+                    store_events=self.store_events,
+                )
             # Execute post-hooks after output is generated but before response is returned
             if self.post_hooks is not None:
-                self._execute_post_hooks(
+                yield from self._execute_post_hooks(
                     hooks=self.post_hooks,  # type: ignore
                     run_output=run_response,
                     session_state=session_state,
@@ -1442,42 +1572,62 @@ class Team:
                     debug_mode=debug_mode,
                     **kwargs,
                 )
+            raise_if_cancelled(run_response.run_id)  # type: ignore
 
-            run_response.status = RunStatus.completed
-            # Set the run duration
-            if run_response.metrics:
-                run_response.metrics.stop_timer()
-
-            # 5. Add the run to Team Session
-            session.upsert_run(run_response=run_response)
-
-            # 6. Update Team Memory
-            yield from self._make_memories_and_summaries(
+            # 8. Wait for background memory creation
+            yield from wait_for_background_tasks_stream(
                 run_response=run_response,
-                run_messages=run_messages,
-                session=session,
-                user_id=user_id,
+                memory_future=memory_future,
+                stream_events=stream_events,
+                events_to_skip=self.events_to_skip,  # type: ignore
+                store_events=self.store_events,
             )
 
-            # 7. Create the run completed event
-            completed_event = self._handle_event(
+            raise_if_cancelled(run_response.run_id)  # type: ignore
+            # 9. Create session summary
+            if self.session_summary_manager is not None:
+                # Upsert the RunOutput to Team Session before creating the session summary
+                session.upsert_run(run_response=run_response)
+
+                if stream_events:
+                    yield handle_event(  # type: ignore
+                        create_team_session_summary_started_event(from_run_response=run_response),
+                        run_response,
+                        events_to_skip=self.events_to_skip,
+                        store_events=self.store_events,
+                    )
+                try:
+                    self.session_summary_manager.create_session_summary(session=session)
+                except Exception as e:
+                    log_warning(f"Error in session summary creation: {str(e)}")
+                if stream_events:
+                    yield handle_event(  # type: ignore
+                        create_team_session_summary_completed_event(
+                            from_run_response=run_response, session_summary=session.summary
+                        ),
+                        run_response,
+                        events_to_skip=self.events_to_skip,
+                        store_events=self.store_events,
+                    )
+
+            raise_if_cancelled(run_response.run_id)  # type: ignore
+            # Create the run completed event
+            completed_event = handle_event(
                 create_team_run_completed_event(
                     from_run_response=run_response,
                 ),
                 run_response,
+                events_to_skip=self.events_to_skip,
+                store_events=self.store_events,
             )
 
-            # 8. Calculate session metrics
-            self._update_session_metrics(session=session)
-
-            # 9. Scrub the stored run based on storage flags
-            if self._scrub_run_output_for_storage(run_response):
-                session.upsert_run(run_response=run_response)
+            # Set the run status to completed
+            run_response.status = RunStatus.completed
 
-            # 10. Save session to storage
-            self.save_session(session=session)
+            # 10. Cleanup and store the run response
+            self._cleanup_and_store(run_response=run_response, session=session)
 
-            if stream_intermediate_steps:
+            if stream_events:
                 yield completed_event
 
             if yield_run_response:
@@ -1495,14 +1645,15 @@ class Team:
             run_response.content = str(e)
 
             # Yield the cancellation event
-            yield self._handle_event(
+            yield handle_event(  # type: ignore
                 create_team_run_cancelled_event(from_run_response=run_response, reason=str(e)),
                 run_response,
+                events_to_skip=self.events_to_skip,
+                store_events=self.store_events,
             )
 
             # Add the RunOutput to Team Session even when cancelled
-            session.upsert_run(run_response=run_response)
-            self.save_session(session=session)
+            self._cleanup_and_store(run_response=run_response, session=session)
         finally:
             # Always clean up the run tracking
             cleanup_run(run_response.run_id)  # type: ignore
@@ -1513,6 +1664,7 @@ class Team:
         input: Union[str, List, Dict, Message, BaseModel, List[Message]],
         *,
         stream: Literal[False] = False,
+        stream_events: Optional[bool] = None,
         stream_intermediate_steps: Optional[bool] = None,
         session_id: Optional[str] = None,
         session_state: Optional[Dict[str, Any]] = None,
@@ -1538,6 +1690,7 @@ class Team:
         input: Union[str, List, Dict, Message, BaseModel, List[Message]],
         *,
         stream: Literal[True] = True,
+        stream_events: Optional[bool] = None,
         stream_intermediate_steps: Optional[bool] = None,
         session_id: Optional[str] = None,
         session_state: Optional[Dict[str, Any]] = None,
@@ -1563,6 +1716,7 @@ class Team:
         input: Union[str, List, Dict, Message, BaseModel, List[Message]],
         *,
         stream: Optional[bool] = None,
+        stream_events: Optional[bool] = None,
         stream_intermediate_steps: Optional[bool] = None,
         session_id: Optional[str] = None,
         session_state: Optional[Dict[str, Any]] = None,
@@ -1586,6 +1740,14 @@ class Team:
         if self._has_async_db():
             raise Exception("run() is not supported with an async DB. Please use arun() instead.")
 
+        # Initialize Team
+        self.initialize_team(debug_mode=debug_mode)
+
+        if (add_history_to_context or self.add_history_to_context) and not self.db and not self.parent_team_id:
+            log_warning(
+                "add_history_to_context is True, but no database has been assigned to the team. History will not be added to the context."
+            )
+
         # Create a run_id for this specific run
         run_id = str(uuid4())
 
@@ -1600,12 +1762,7 @@ class Team:
                 self.post_hooks = normalize_hooks(self.post_hooks)
             self._hooks_normalised = True
 
-        session_id, user_id, session_state = self._initialize_session(
-            run_id=run_id, session_id=session_id, user_id=user_id, session_state=session_state
-        )
-
-        # Initialize Team
-        self.initialize_team(debug_mode=debug_mode)
+        session_id, user_id = self._initialize_session(session_id=session_id, user_id=user_id)
 
         image_artifacts, video_artifacts, audio_artifacts, file_artifacts = self._validate_media_object_id(
             images=images, videos=videos, audios=audio, files=files
@@ -1624,6 +1781,10 @@ class Team:
         team_session = self._read_or_create_session(session_id=session_id, user_id=user_id)
         self._update_metadata(session=team_session)
 
+        # Initialize session state
+        session_state = self._initialize_session_state(
+            session_state=session_state or {}, user_id=user_id, session_id=session_id, run_id=run_id
+        )
         # Update session state from DB
         session_state = self._load_session_state(session=team_session, session_state=session_state)
 
@@ -1656,17 +1817,18 @@ class Team:
         if stream is None:
             stream = False if self.stream is None else self.stream
 
-        if stream_intermediate_steps is None:
-            stream_intermediate_steps = (
-                False if self.stream_intermediate_steps is None else self.stream_intermediate_steps
-            )
+        # Considering both stream_events and stream_intermediate_steps (deprecated)
+        stream_events = stream_events or stream_intermediate_steps
 
-        # Can't have stream_intermediate_steps if stream is False
+        # Can't stream events if streaming is disabled
         if stream is False:
-            stream_intermediate_steps = False
+            stream_events = False
+
+        if stream_events is None:
+            stream_events = False if self.stream_events is None else self.stream_events
 
         self.stream = self.stream or stream
-        self.stream_intermediate_steps = self.stream_intermediate_steps or (stream_intermediate_steps and self.stream)
+        self.stream_events = self.stream_events or stream_events
 
         # Configure the model for runs
         response_format: Optional[Union[Dict, Type[BaseModel]]] = (
@@ -1722,7 +1884,7 @@ class Team:
                         metadata=metadata,
                         dependencies=run_dependencies,
                         response_format=response_format,
-                        stream_intermediate_steps=stream_intermediate_steps,
+                        stream_events=stream_events,
                         yield_run_response=yield_run_response,
                         debug_mode=debug_mode,
                         **kwargs,
@@ -1761,17 +1923,6 @@ class Team:
                     else:
                         delay = self.delay_between_retries
                     time.sleep(delay)
-            except RunCancelledException as e:
-                # Handle run cancellation
-                log_info(f"Team run {run_response.run_id} was cancelled")
-                run_response.content = str(e)
-                run_response.status = RunStatus.cancelled
-
-                # Add the RunOutput to Team Session even when cancelled
-                team_session.upsert_run(run_response=run_response)
-                self.save_session(session=team_session)
-
-                return run_response
             except KeyboardInterrupt:
                 run_response.content = "Operation cancelled by user"
                 run_response.status = RunStatus.cancelled
@@ -1812,10 +1963,6 @@ class Team:
         add_history_to_context: Optional[bool] = None,
         knowledge_filters: Optional[Dict[str, Any]] = None,
         metadata: Optional[Dict[str, Any]] = None,
-        audio: Optional[Sequence[Audio]] = None,
-        images: Optional[Sequence[Image]] = None,
-        videos: Optional[Sequence[Video]] = None,
-        files: Optional[Sequence[File]] = None,
         debug_mode: Optional[bool] = None,
         dependencies: Optional[Dict[str, Any]] = None,
         **kwargs: Any,
@@ -1828,16 +1975,16 @@ class Team:
         3. Execute pre-hooks
         4. Determine tools for model
         5. Prepare run messages
-        6. Reason about the task if reasoning is enabled
-        7. Get a response from the Model (includes running function calls)
-        8. Update TeamRunOutput
-        9. Add the run to memory
-        10. Calculate session metrics
-        11. Parse team response model
-        12. Update Team Memory
-        13. Scrub the stored run if needed
-        14. Save session to storage
-        15. Execute post-hooks
+        6. Start memory creation in background task
+        7. Reason about the task if reasoning is enabled
+        8. Get a response from the Model
+        9. Update TeamRunOutput with the model response
+        10. Store media if enabled
+        11. Convert response to structured format
+        12. Execute post-hooks
+        13. Wait for background memory creation
+        14. Create session summary
+        15. Cleanup and store (scrub, add to session, calculate metrics, save session)
         """
         log_debug(f"Team Run Start: {run_response.run_id}", center=True)
 
@@ -1854,6 +2001,11 @@ class Team:
 
         # 2. Update metadata and session state
         self._update_metadata(session=team_session)
+        # Initialize session state
+        session_state = self._initialize_session_state(
+            session_state=session_state or {}, user_id=user_id, session_id=session_id, run_id=run_response.run_id
+        )
+        # Update session state from DB
         session_state = self._load_session_state(session=team_session, session_state=session_state)  # type: ignore
 
         run_input = cast(TeamRunInput, run_response.input)
@@ -1909,10 +2061,10 @@ class Team:
             session_state=session_state,
             user_id=user_id,
             input_message=run_input.input_content,
-            audio=audio,
-            images=images,
-            videos=videos,
-            files=files,
+            audio=run_input.audios,
+            images=run_input.images,
+            videos=run_input.videos,
+            files=run_input.files,
             knowledge_filters=knowledge_filters,
             add_history_to_context=add_history_to_context,
             dependencies=dependencies,
@@ -1921,98 +2073,119 @@ class Team:
             **kwargs,
         )
 
+        self.model = cast(Model, self.model)
+        log_debug(f"Team Run Start: {run_response.run_id}", center=True)
+
+        # 6. Start memory creation in background task
+        import asyncio
+
+        memory_task = None
+        if run_messages.user_message is not None and self.memory_manager is not None and not self.enable_agentic_memory:
+            log_debug("Starting memory creation in background task.")
+            memory_task = asyncio.create_task(self._amake_memories(run_messages=run_messages, user_id=user_id))
+
         # Register run for cancellation tracking
         register_run(run_response.run_id)  # type: ignore
 
-        # 6. Reason about the task(s) if reasoning is enabled
-        await self._ahandle_reasoning(run_response=run_response, run_messages=run_messages)
+        try:
+            raise_if_cancelled(run_response.run_id)  # type: ignore
+            # 7. Reason about the task if reasoning is enabled
+            await self._ahandle_reasoning(run_response=run_response, run_messages=run_messages)
 
-        # Check for cancellation before model call
-        raise_if_cancelled(run_response.run_id)  # type: ignore
+            # Check for cancellation before model call
+            raise_if_cancelled(run_response.run_id)  # type: ignore
 
-        # 7. Get the model response for the team leader
-        self.model = cast(Model, self.model)
-        model_response = await self.model.aresponse(
-            messages=run_messages.messages,
-            tools=self._tools_for_model,
-            functions=self._functions_for_model,
-            tool_choice=self.tool_choice,
-            tool_call_limit=self.tool_call_limit,
-            response_format=response_format,
-            send_media_to_model=self.send_media_to_model,
-        )  # type: ignore
-        raise_if_cancelled(run_response.run_id)  # type: ignore
+            # 8. Get the model response for the team leader
+            model_response = await self.model.aresponse(
+                messages=run_messages.messages,
+                tools=self._tools_for_model,
+                functions=self._functions_for_model,
+                tool_choice=self.tool_choice,
+                tool_call_limit=self.tool_call_limit,
+                response_format=response_format,
+                send_media_to_model=self.send_media_to_model,
+            )  # type: ignore
+
+            # Check for cancellation after model call
+            raise_if_cancelled(run_response.run_id)  # type: ignore
 
-        # If an output model is provided, generate output using the output model
-        await self._agenerate_response_with_output_model(model_response=model_response, run_messages=run_messages)
-        # If a parser model is provided, structure the response separately
-        await self._aparse_response_with_parser_model(model_response=model_response, run_messages=run_messages)
+            # If an output model is provided, generate output using the output model
+            await self._agenerate_response_with_output_model(model_response=model_response, run_messages=run_messages)
 
-        # 8. Update TeamRunOutput
-        self._update_run_response(model_response=model_response, run_response=run_response, run_messages=run_messages)
+            # If a parser model is provided, structure the response separately
+            await self._aparse_response_with_parser_model(model_response=model_response, run_messages=run_messages)
 
-        # Optional: Store media
-        if self.store_media:
-            self._store_media(run_response, model_response)
-        else:
-            self._scrub_media_from_run_output(run_response)
+            # 9. Update TeamRunOutput with the model response
+            self._update_run_response(
+                model_response=model_response, run_response=run_response, run_messages=run_messages
+            )
 
-        # 11. Parse team response model
-        self._convert_response_to_structured_format(run_response=run_response)
+            # 10. Store media if enabled
+            if self.store_media:
+                self._store_media(run_response, model_response)
 
-        # Execute post-hooks after output is generated but before response is returned
-        if self.post_hooks is not None:
-            await self._aexecute_post_hooks(
-                hooks=self.post_hooks,  # type: ignore
-                run_output=run_response,
-                session=team_session,
-                user_id=user_id,
-                debug_mode=debug_mode,
-                session_state=session_state,
-                dependencies=dependencies,
-                metadata=metadata,
-                **kwargs,
-            )
+            # 11. Convert response to structured format
+            self._convert_response_to_structured_format(run_response=run_response)
 
-        run_response.status = RunStatus.completed
+            # 12. Execute post-hooks after output is generated but before response is returned
+            if self.post_hooks is not None:
+                async for _ in self._aexecute_post_hooks(
+                    hooks=self.post_hooks,  # type: ignore
+                    run_output=run_response,
+                    session=team_session,
+                    user_id=user_id,
+                    debug_mode=debug_mode,
+                    **kwargs,
+                ):
+                    pass
 
-        # Set the run duration
-        if run_response.metrics:
-            run_response.metrics.stop_timer()
+            raise_if_cancelled(run_response.run_id)  # type: ignore
 
-        # 9. Add the run to memory
-        team_session.upsert_run(run_response=run_response)
+            # 13. Wait for background memory creation
+            await await_for_background_tasks(memory_task=memory_task)
 
-        # 10. Calculate session metrics
-        self._update_session_metrics(session=team_session)
+            raise_if_cancelled(run_response.run_id)  # type: ignore
+            # 14. Create session summary
+            if self.session_summary_manager is not None:
+                # Upsert the RunOutput to Team Session before creating the session summary
+                team_session.upsert_run(run_response=run_response)
+                try:
+                    await self.session_summary_manager.acreate_session_summary(session=team_session)
+                except Exception as e:
+                    log_warning(f"Error in session summary creation: {str(e)}")
 
-        # 12. Update Team Memory
-        async for _ in self._amake_memories_and_summaries(
-            run_response=run_response,
-            session=team_session,
-            run_messages=run_messages,
-            user_id=user_id,
-        ):
-            pass
+            raise_if_cancelled(run_response.run_id)  # type: ignore
+            run_response.status = RunStatus.completed
 
-        # 13. Scrub the stored run based on storage flags
-        if self._scrub_run_output_for_storage(run_response):
-            team_session.upsert_run(run_response=run_response)
+            # 15. Cleanup and store the run response and session
+            await self._acleanup_and_store(run_response=run_response, session=team_session)
 
-        # 14. Save session to storage
-        if self._has_async_db():
-            await self.asave_session(session=team_session)
-        else:
-            self.save_session(session=team_session)
+            # Log Team Telemetry
+            await self._alog_team_telemetry(session_id=team_session.session_id, run_id=run_response.run_id)
 
-        #  Log Team Telemetry
-        await self._alog_team_telemetry(session_id=team_session.session_id, run_id=run_response.run_id)
+            log_debug(f"Team Run End: {run_response.run_id}", center=True, symbol="*")
 
-        log_debug(f"Team Run End: {run_response.run_id}", center=True, symbol="*")
+            return run_response
+        except RunCancelledException as e:
+            # Handle run cancellation
+            log_info(f"Run {run_response.run_id} was cancelled")
+            run_response.content = str(e)
+            run_response.status = RunStatus.cancelled
 
-        cleanup_run(run_response.run_id)  # type: ignore
+            # Cleanup and store the run response and session
+            await self._acleanup_and_store(run_response=run_response, session=team_session)
 
-        return run_response
+            return run_response
+        finally:
+            # Cancel the memory task if it's still running
+            if memory_task is not None and not memory_task.done():
+                memory_task.cancel()
+                try:
+                    await memory_task
+                except asyncio.CancelledError:
+                    pass
+            # Always clean up the run tracking
+            cleanup_run(run_response.run_id)  # type: ignore
 
     async def _arun_stream(
         self,
@@ -2021,6 +2194,7 @@ class Team:
         session_state: Optional[Dict[str, Any]] = None,
         user_id: Optional[str] = None,
         response_format: Optional[Union[Dict, Type[BaseModel]]] = None,
+        stream_events: bool = False,
         stream_intermediate_steps: bool = False,
         yield_run_response: bool = False,
         add_dependencies_to_context: Optional[bool] = None,
@@ -2028,10 +2202,6 @@ class Team:
         add_history_to_context: Optional[bool] = None,
         knowledge_filters: Optional[Dict[str, Any]] = None,
         metadata: Optional[Dict[str, Any]] = None,
-        audio: Optional[Sequence[Audio]] = None,
-        images: Optional[Sequence[Image]] = None,
-        videos: Optional[Sequence[Video]] = None,
-        files: Optional[Sequence[File]] = None,
         debug_mode: Optional[bool] = None,
         dependencies: Optional[Dict[str, Any]] = None,
         **kwargs: Any,
@@ -2045,15 +2215,13 @@ class Team:
         4. Execute pre-hooks
         5. Determine tools for model
         6. Prepare run messages
-        7. Yield the run started event
-        8. Reason about the task(s) if reasoning is enabled
+        7. Start memory creation in background task
+        8. Reason about the task if reasoning is enabled
         9. Get a response from the model
-        10. Add the run to memory
-        11. Update Team Memory
-        12. Calculate session metrics
-        13. Create the run completed event
-        14. Scrub the stored run if needed
-        15. Save session to storage
+        10. Parse response with parser model if provided
+        11. Wait for background memory creation
+        12. Create session summary
+        13. Cleanup and store (scrub, add to session, calculate metrics, save session)
         """
 
         # 1. Resolve dependencies
@@ -2068,6 +2236,11 @@ class Team:
 
         # 3. Update metadata and session state
         self._update_metadata(session=team_session)
+        # Initialize session state
+        session_state = self._initialize_session_state(
+            session_state=session_state or {}, user_id=user_id, session_id=session_id, run_id=run_response.run_id
+        )
+        # Update session state from DB
         session_state = self._load_session_state(session=team_session, session_state=session_state)  # type: ignore
 
         # 4. Execute pre-hooks
@@ -2102,10 +2275,10 @@ class Team:
             async_mode=True,
             knowledge_filters=knowledge_filters,
             input_message=run_input.input_content,
-            images=images,
-            videos=videos,
-            audio=audio,
-            files=files,
+            images=run_input.images,
+            videos=run_input.videos,
+            audio=run_input.audios,
+            files=run_input.files,
             debug_mode=debug_mode,
             add_history_to_context=add_history_to_context,
             dependencies=dependencies,
@@ -2119,10 +2292,10 @@ class Team:
             session_state=session_state,
             user_id=user_id,
             input_message=run_input.input_content,
-            audio=audio,
-            images=images,
-            videos=videos,
-            files=files,
+            audio=run_input.audios,
+            images=run_input.images,
+            videos=run_input.videos,
+            files=run_input.files,
             knowledge_filters=knowledge_filters,
             add_history_to_context=add_history_to_context,
             dependencies=dependencies,
@@ -2134,16 +2307,36 @@ class Team:
 
         log_debug(f"Team Run Start: {run_response.run_id}", center=True)
 
+        # 7. Start memory creation in background task
+        import asyncio
+
+        memory_task = None
+        if run_messages.user_message is not None and self.memory_manager is not None and not self.enable_agentic_memory:
+            log_debug("Starting memory creation in background task.")
+            memory_task = asyncio.create_task(self._amake_memories(run_messages=run_messages, user_id=user_id))
+
         # Register run for cancellation tracking
         register_run(run_response.run_id)  # type: ignore
 
         try:
-            # 7. Yield the run started event
-            if stream_intermediate_steps:
-                yield self._handle_event(create_team_run_started_event(from_run_response=run_response), run_response)
+            # Considering both stream_events and stream_intermediate_steps (deprecated)
+            stream_events = stream_events or stream_intermediate_steps
+
+            # Yield the run started event
+            if stream_events:
+                yield handle_event(  # type: ignore
+                    create_team_run_started_event(from_run_response=run_response),
+                    run_response,
+                    events_to_skip=self.events_to_skip,
+                    store_events=self.store_events,
+                )
 
-            # 8. Reason about the task(s) if reasoning is enabled
-            async for item in self._ahandle_reasoning_stream(run_response=run_response, run_messages=run_messages):
+            # 8. Reason about the task if reasoning is enabled
+            async for item in self._ahandle_reasoning_stream(
+                run_response=run_response,
+                run_messages=run_messages,
+                stream_events=stream_events,
+            ):
                 raise_if_cancelled(run_response.run_id)  # type: ignore
                 yield item
 
@@ -2157,7 +2350,7 @@ class Team:
                     run_response=run_response,
                     run_messages=run_messages,
                     response_format=response_format,
-                    stream_intermediate_steps=stream_intermediate_steps,
+                    stream_events=stream_events,
                 ):
                     raise_if_cancelled(run_response.run_id)  # type: ignore
                     yield event
@@ -2167,13 +2360,13 @@ class Team:
                     run_response=run_response,
                     run_messages=run_messages,
                     response_format=response_format,
-                    stream_intermediate_steps=stream_intermediate_steps,
+                    stream_events=stream_events,
                 ):
                     raise_if_cancelled(run_response.run_id)  # type: ignore
                     from agno.run.team import IntermediateRunContentEvent, RunContentEvent
 
                     if isinstance(event, RunContentEvent):
-                        if stream_intermediate_steps:
+                        if stream_events:
                             yield IntermediateRunContentEvent(
                                 content=event.content,
                                 content_type=event.content_type,
@@ -2185,7 +2378,7 @@ class Team:
                     session=team_session,
                     run_response=run_response,
                     run_messages=run_messages,
-                    stream_intermediate_steps=stream_intermediate_steps,
+                    stream_events=stream_events,
                 ):
                     raise_if_cancelled(run_response.run_id)  # type: ignore
                     yield event
@@ -2193,15 +2386,24 @@ class Team:
             # Check for cancellation after model processing
             raise_if_cancelled(run_response.run_id)  # type: ignore
 
-            # If a parser model is provided, structure the response separately
+            # 10. Parse response with parser model if provided
             async for event in self._aparse_response_with_parser_model_stream(
-                session=team_session, run_response=run_response, stream_intermediate_steps=stream_intermediate_steps
+                session=team_session, run_response=run_response, stream_events=stream_events
             ):
                 yield event
 
+            # Yield RunContentCompletedEvent
+            if stream_events:
+                yield handle_event(  # type: ignore
+                    create_team_run_content_completed_event(from_run_response=run_response),
+                    run_response,
+                    events_to_skip=self.events_to_skip,
+                    store_events=self.store_events,
+                )
+
             # Execute post-hooks after output is generated but before response is returned
             if self.post_hooks is not None:
-                await self._aexecute_post_hooks(
+                async for event in self._aexecute_post_hooks(
                     hooks=self.post_hooks,  # type: ignore
                     run_output=run_response,
                     session_state=session_state,
@@ -2211,45 +2413,65 @@ class Team:
                     user_id=user_id,
                     debug_mode=debug_mode,
                     **kwargs,
-                )
-
-            # Set the run duration
-            if run_response.metrics:
-                run_response.metrics.stop_timer()
-
-            run_response.status = RunStatus.completed
-
-            # 10. Add the run to memory
-            team_session.upsert_run(run_response=run_response)
+                ):
+                    yield event
 
-            # 11. Update Team Memory
-            async for event in self._amake_memories_and_summaries(
+            raise_if_cancelled(run_response.run_id)  # type: ignore
+            # 11. Wait for background memory creation
+            async for event in await_for_background_tasks_stream(
                 run_response=run_response,
-                session=team_session,
-                run_messages=run_messages,
-                user_id=user_id,
+                memory_task=memory_task,
+                stream_events=stream_events,
+                events_to_skip=self.events_to_skip,  # type: ignore
+                store_events=self.store_events,
             ):
                 yield event
 
-            # 12. Calculate session metrics
-            self._update_session_metrics(session=team_session)
+            raise_if_cancelled(run_response.run_id)  # type: ignore
+
+            # 12. Create session summary
+            if self.session_summary_manager is not None:
+                # Upsert the RunOutput to Team Session before creating the session summary
+                team_session.upsert_run(run_response=run_response)
+
+                if stream_events:
+                    yield handle_event(  # type: ignore
+                        create_team_session_summary_started_event(from_run_response=run_response),
+                        run_response,
+                        events_to_skip=self.events_to_skip,
+                        store_events=self.store_events,
+                    )
+                try:
+                    await self.session_summary_manager.acreate_session_summary(session=team_session)
+                except Exception as e:
+                    log_warning(f"Error in session summary creation: {str(e)}")
+                if stream_events:
+                    yield handle_event(  # type: ignore
+                        create_team_session_summary_completed_event(
+                            from_run_response=run_response, session_summary=team_session.summary
+                        ),
+                        run_response,
+                        events_to_skip=self.events_to_skip,
+                        store_events=self.store_events,
+                    )
+
+            raise_if_cancelled(run_response.run_id)  # type: ignore
 
-            # 13. Create the run completed event
-            completed_event = self._handle_event(
-                create_team_run_completed_event(from_run_response=run_response), run_response
+            # Create the run completed event
+            completed_event = handle_event(
+                create_team_run_completed_event(from_run_response=run_response),
+                run_response,
+                events_to_skip=self.events_to_skip,
+                store_events=self.store_events,
             )
 
-            # 14. Scrub the stored run based on storage flags
-            if self._scrub_run_output_for_storage(run_response):
-                team_session.upsert_run(run_response=run_response)
+            # Set the run status to completed
+            run_response.status = RunStatus.completed
 
-            # 15. Save the session to storage
-            if self._has_async_db():
-                await self.asave_session(session=team_session)
-            else:
-                self.save_session(session=team_session)
+            # 13. Cleanup and store the run response and session
+            await self._acleanup_and_store(run_response=run_response, session=team_session)
 
-            if stream_intermediate_steps:
+            if stream_events:
                 yield completed_event
 
             if yield_run_response:
@@ -2267,18 +2489,24 @@ class Team:
             run_response.content = str(e)
 
             # Yield the cancellation event
-            yield self._handle_event(
+            yield handle_event(  # type: ignore
                 create_team_run_cancelled_event(from_run_response=run_response, reason=str(e)),
                 run_response,
+                events_to_skip=self.events_to_skip,
+                store_events=self.store_events,
             )
 
-            # Add the RunOutput to Team Session even when cancelled
-            team_session.upsert_run(run_response=run_response)
-            if self._has_async_db():
-                await self.asave_session(session=team_session)
-            else:
-                self.save_session(session=team_session)
+            # Cleanup and store the run response and session
+            await self._acleanup_and_store(run_response=run_response, session=team_session)
+
         finally:
+            # Cancel the memory task if it's still running
+            if memory_task is not None and not memory_task.done():
+                memory_task.cancel()
+                try:
+                    await memory_task
+                except asyncio.CancelledError:
+                    pass
             # Always clean up the run tracking
             cleanup_run(run_response.run_id)  # type: ignore
 
@@ -2288,6 +2516,7 @@ class Team:
         input: Union[str, List, Dict, Message, BaseModel],
         *,
         stream: Literal[False] = False,
+        stream_events: Optional[bool] = None,
         stream_intermediate_steps: Optional[bool] = None,
         session_id: Optional[str] = None,
         session_state: Optional[Dict[str, Any]] = None,
@@ -2313,6 +2542,7 @@ class Team:
         input: Union[str, List, Dict, Message, BaseModel],
         *,
         stream: Literal[True] = True,
+        stream_events: Optional[bool] = None,
         stream_intermediate_steps: Optional[bool] = None,
         session_id: Optional[str] = None,
         session_state: Optional[Dict[str, Any]] = None,
@@ -2338,6 +2568,7 @@ class Team:
         input: Union[str, List, Dict, Message, BaseModel],
         *,
         stream: Optional[bool] = None,
+        stream_events: Optional[bool] = None,
         stream_intermediate_steps: Optional[bool] = None,
         session_id: Optional[str] = None,
         session_state: Optional[Dict[str, Any]] = None,
@@ -2359,6 +2590,11 @@ class Team:
     ) -> Union[TeamRunOutput, AsyncIterator[Union[RunOutputEvent, TeamRunOutputEvent]]]:
         """Run the Team asynchronously and return the response."""
 
+        if (add_history_to_context or self.add_history_to_context) and not self.db and not self.parent_team_id:
+            log_warning(
+                "add_history_to_context is True, but no database has been assigned to the team. History will not be added to the context."
+            )
+
         # Create a run_id for this specific run
         run_id = str(uuid4())
 
@@ -2373,9 +2609,7 @@ class Team:
                 self.post_hooks = normalize_hooks(self.post_hooks, async_mode=True)
             self._hooks_normalised = True
 
-        session_id, user_id, session_state = self._initialize_session(
-            run_id=run_id, session_id=session_id, user_id=user_id, session_state=session_state
-        )
+        session_id, user_id = self._initialize_session(session_id=session_id, user_id=user_id)
 
         # Initialize Team
         self.initialize_team(debug_mode=debug_mode)
@@ -2409,17 +2643,18 @@ class Team:
         if stream is None:
             stream = False if self.stream is None else self.stream
 
-        if stream_intermediate_steps is None:
-            stream_intermediate_steps = (
-                False if self.stream_intermediate_steps is None else self.stream_intermediate_steps
-            )
+        # Considering both stream_events and stream_intermediate_steps (deprecated)
+        stream_events = stream_events or stream_intermediate_steps
 
-        # Can't have stream_intermediate_steps if stream is False
+        # Can't stream events if streaming is disabled
         if stream is False:
-            stream_intermediate_steps = False
+            stream_events = False
+
+        if stream_events is None:
+            stream_events = False if self.stream_events is None else self.stream_events
 
         self.stream = self.stream or stream
-        self.stream_intermediate_steps = self.stream_intermediate_steps or (stream_intermediate_steps and self.stream)
+        self.stream_events = self.stream_events or stream_events
 
         # Configure the model for runs
         response_format: Optional[Union[Dict, Type[BaseModel]]] = (
@@ -2480,7 +2715,7 @@ class Team:
                         metadata=metadata,
                         response_format=response_format,
                         dependencies=run_dependencies,
-                        stream_intermediate_steps=stream_intermediate_steps,
+                        stream_events=stream_events,
                         yield_run_response=yield_run_response,
                         debug_mode=debug_mode,
                         **kwargs,
@@ -2493,10 +2728,6 @@ class Team:
                         session_id=session_id,
                         session_state=session_state,
                         user_id=user_id,
-                        audio=audio,
-                        images=images,
-                        videos=videos,
-                        files=files,
                         knowledge_filters=effective_filters,
                         add_history_to_context=add_history,
                         add_dependencies_to_context=add_dependencies,
@@ -2631,7 +2862,7 @@ class Team:
         run_response: TeamRunOutput,
         run_messages: RunMessages,
         response_format: Optional[Union[Dict, Type[BaseModel]]] = None,
-        stream_intermediate_steps: bool = False,
+        stream_events: bool = False,
     ) -> Iterator[Union[TeamRunOutputEvent, RunOutputEvent]]:
         self.model = cast(Model, self.model)
 
@@ -2662,7 +2893,7 @@ class Team:
                 full_model_response=full_model_response,
                 model_response_event=model_response_event,
                 reasoning_state=reasoning_state,
-                stream_intermediate_steps=stream_intermediate_steps,
+                stream_events=stream_events,
                 parse_structured_output=self.should_parse_structured_output,
             )
 
@@ -2678,20 +2909,22 @@ class Team:
         if full_model_response.provider_data is not None:
             run_response.model_provider_data = full_model_response.provider_data
 
-        if stream_intermediate_steps and reasoning_state["reasoning_started"]:
+        if stream_events and reasoning_state["reasoning_started"]:
             all_reasoning_steps: List[ReasoningStep] = []
             if run_response.reasoning_steps:
                 all_reasoning_steps = cast(List[ReasoningStep], run_response.reasoning_steps)
 
             if all_reasoning_steps:
                 add_reasoning_metrics_to_metadata(run_response, reasoning_state["reasoning_time_taken"])
-                yield self._handle_event(
+                yield handle_event(  # type: ignore
                     create_team_reasoning_completed_event(
                         from_run_response=run_response,
                         content=ReasoningSteps(reasoning_steps=all_reasoning_steps),
                         content_type=ReasoningSteps.__name__,
                     ),
                     run_response,
+                    events_to_skip=self.events_to_skip,
+                    store_events=self.store_events,
                 )
 
         # Build a list of messages that should be added to the RunOutput
@@ -2711,7 +2944,7 @@ class Team:
         run_response: TeamRunOutput,
         run_messages: RunMessages,
         response_format: Optional[Union[Dict, Type[BaseModel]]] = None,
-        stream_intermediate_steps: bool = False,
+        stream_events: bool = False,
     ) -> AsyncIterator[Union[TeamRunOutputEvent, RunOutputEvent]]:
         self.model = cast(Model, self.model)
 
@@ -2743,7 +2976,7 @@ class Team:
                 full_model_response=full_model_response,
                 model_response_event=model_response_event,
                 reasoning_state=reasoning_state,
-                stream_intermediate_steps=stream_intermediate_steps,
+                stream_events=stream_events,
                 parse_structured_output=self.should_parse_structured_output,
             ):
                 yield event
@@ -2772,20 +3005,22 @@ class Team:
         # Update the TeamRunOutput metrics
         run_response.metrics = self._calculate_metrics(messages_for_run_response)
 
-        if stream_intermediate_steps and reasoning_state["reasoning_started"]:
+        if stream_events and reasoning_state["reasoning_started"]:
             all_reasoning_steps: List[ReasoningStep] = []
             if run_response.reasoning_steps:
                 all_reasoning_steps = cast(List[ReasoningStep], run_response.reasoning_steps)
 
             if all_reasoning_steps:
                 add_reasoning_metrics_to_metadata(run_response, reasoning_state["reasoning_time_taken"])
-                yield self._handle_event(
+                yield handle_event(  # type: ignore
                     create_team_reasoning_completed_event(
                         from_run_response=run_response,
                         content=ReasoningSteps(reasoning_steps=all_reasoning_steps),
                         content_type=ReasoningSteps.__name__,
                     ),
                     run_response,
+                    events_to_skip=self.events_to_skip,
+                    store_events=self.store_events,
                 )
 
     def _handle_model_response_chunk(
@@ -2795,7 +3030,7 @@ class Team:
         full_model_response: ModelResponse,
         model_response_event: Union[ModelResponse, TeamRunOutputEvent, RunOutputEvent],
         reasoning_state: Optional[Dict[str, Any]] = None,
-        stream_intermediate_steps: bool = False,
+        stream_events: bool = False,
         parse_structured_output: bool = False,
     ) -> Iterator[Union[TeamRunOutputEvent, RunOutputEvent]]:
         if isinstance(model_response_event, tuple(get_args(RunOutputEvent))) or isinstance(
@@ -2812,7 +3047,12 @@ class Team:
                     if not model_response_event.run_id:  # type: ignore
                         model_response_event.run_id = run_response.run_id  # type: ignore
                 # We just bubble the event up
-                yield self._handle_event(model_response_event, run_response)  # type: ignore
+                yield handle_event(  # type: ignore
+                    model_response_event,  # type: ignore
+                    run_response,
+                    events_to_skip=self.events_to_skip,
+                    store_events=self.store_events,
+                )  # type: ignore
             else:
                 # Don't yield anything
                 return
@@ -2918,7 +3158,7 @@ class Team:
                 # Only yield the chunk
                 if should_yield:
                     if content_type == "str":
-                        yield self._handle_event(
+                        yield handle_event(  # type: ignore
                             create_team_run_output_content_event(
                                 from_run_response=run_response,
                                 content=model_response_event.content,
@@ -2930,15 +3170,19 @@ class Team:
                                 image=model_response_event.images[-1] if model_response_event.images else None,
                             ),
                             run_response,
+                            events_to_skip=self.events_to_skip,
+                            store_events=self.store_events,
                         )
                     else:
-                        yield self._handle_event(
+                        yield handle_event(  # type: ignore
                             create_team_run_output_content_event(
                                 from_run_response=run_response,
                                 content=full_model_response.content,
                                 content_type=content_type,
                             ),
                             run_response,
+                            events_to_skip=self.events_to_skip,
+                            store_events=self.store_events,
                         )
 
             # If the model response is a tool_call_started, add the tool call to the run_response
@@ -2953,12 +3197,14 @@ class Team:
                         run_response.tools.extend(tool_executions_list)
 
                     for tool in tool_executions_list:
-                        yield self._handle_event(
+                        yield handle_event(  # type: ignore
                             create_team_tool_call_started_event(
                                 from_run_response=run_response,
                                 tool=tool,
                             ),
                             run_response,
+                            events_to_skip=self.events_to_skip,
+                            store_events=self.store_events,
                         )
 
             # If the model response is a tool_call_completed, update the existing tool call in the run_response
@@ -3016,33 +3262,39 @@ class Team:
                                     "reasoning_time_taken"
                                 ] + float(metrics.duration)
 
-                        yield self._handle_event(
+                        yield handle_event(  # type: ignore
                             create_team_tool_call_completed_event(
                                 from_run_response=run_response,
                                 tool=tool_call,
                                 content=model_response_event.content,
                             ),
                             run_response,
+                            events_to_skip=self.events_to_skip,
+                            store_events=self.store_events,
                         )
 
-                if stream_intermediate_steps:
+                if stream_events:
                     if reasoning_step is not None:
                         if reasoning_state is not None and not reasoning_state["reasoning_started"]:
-                            yield self._handle_event(
+                            yield handle_event(  # type: ignore
                                 create_team_reasoning_started_event(
                                     from_run_response=run_response,
                                 ),
                                 run_response,
+                                events_to_skip=self.events_to_skip,
+                                store_events=self.store_events,
                             )
                             reasoning_state["reasoning_started"] = True
 
-                        yield self._handle_event(
+                        yield handle_event(  # type: ignore
                             create_team_reasoning_step_event(
                                 from_run_response=run_response,
                                 reasoning_step=reasoning_step,
                                 reasoning_content=run_response.reasoning_content or "",
                             ),
                             run_response,
+                            events_to_skip=self.events_to_skip,
+                            store_events=self.store_events,
                         )
 
     def _convert_response_to_structured_format(self, run_response: Union[TeamRunOutput, RunOutput, ModelResponse]):
@@ -3083,97 +3335,71 @@ class Team:
             else:
                 log_warning("Something went wrong. Member run response content is not a string")
 
-    def _make_memories_and_summaries(
-        self,
-        run_response: TeamRunOutput,
-        run_messages: RunMessages,
-        session: TeamSession,
-        user_id: Optional[str] = None,
-    ) -> Iterator[TeamRunOutputEvent]:
-        from concurrent.futures import ThreadPoolExecutor, as_completed
+    def _cleanup_and_store(self, run_response: TeamRunOutput, session: TeamSession) -> None:
+        #  Scrub the stored run based on storage flags
+        self._scrub_run_output_for_storage(run_response)
 
-        # Create a thread pool with a reasonable number of workers
-        with ThreadPoolExecutor(max_workers=3) as executor:
-            futures = []
-            user_message_str = (
-                run_messages.user_message.get_content_string() if run_messages.user_message is not None else None
-            )
-            # Create user memories
-            if user_message_str is not None and self.memory_manager is not None and not self.enable_agentic_memory:
-                futures.append(
-                    executor.submit(
-                        self.memory_manager.create_user_memories,
-                        message=user_message_str,
-                        user_id=user_id,
-                        team_id=self.id,
-                    )
-                )
+        # Stop the timer for the Run duration
+        if run_response.metrics:
+            run_response.metrics.stop_timer()
 
-            # Create session summary
-            if self.session_summary_manager is not None:
-                log_debug("Creating session summary.")
-                futures.append(
-                    executor.submit(
-                        self.session_summary_manager.create_session_summary,  # type: ignore
-                        session=session,
-                    )
-                )
+        # Add RunOutput to Agent Session
+        session.upsert_run(run_response=run_response)
 
-            if futures:
-                if self.stream_intermediate_steps:
-                    yield self._handle_event(
-                        create_team_memory_update_started_event(from_run_response=run_response), run_response
-                    )
+        # Calculate session metrics
+        self._update_session_metrics(session=session)
+
+        # Save session to memory
+        self.save_session(session=session)
+
+    async def _acleanup_and_store(self, run_response: TeamRunOutput, session: TeamSession) -> None:
+        #  Scrub the stored run based on storage flags
+        self._scrub_run_output_for_storage(run_response)
+
+        # Stop the timer for the Run duration
+        if run_response.metrics:
+            run_response.metrics.stop_timer()
+
+        # Add RunOutput to Agent Session
+        session.upsert_run(run_response=run_response)
 
-                # Wait for all operations to complete and handle any errors
-                for future in as_completed(futures):
-                    try:
-                        future.result()
-                    except Exception as e:
-                        log_warning(f"Error in memory/summary operation: {str(e)}")
+        # Calculate session metrics
+        self._update_session_metrics(session=session)
 
-                if self.stream_intermediate_steps:
-                    yield self._handle_event(
-                        create_team_memory_update_completed_event(from_run_response=run_response),
-                        run_response,
-                    )
+        # Save session to memory
+        self.save_session(session=session)
 
-    async def _amake_memories_and_summaries(
+    def _make_memories(
         self,
-        run_response: TeamRunOutput,
         run_messages: RunMessages,
-        session: TeamSession,
         user_id: Optional[str] = None,
-    ) -> AsyncIterator[TeamRunOutputEvent]:
-        tasks: List[Coroutine] = []
-
+    ):
         user_message_str = (
             run_messages.user_message.get_content_string() if run_messages.user_message is not None else None
         )
-        if user_message_str is not None and self.memory_manager is not None and not self.enable_agentic_memory:
-            tasks.append(
-                self.memory_manager.acreate_user_memories(message=user_message_str, user_id=user_id, team_id=self.id)
+        if user_message_str is not None and user_message_str.strip() != "" and self.memory_manager is not None:
+            log_debug("Creating user memories.")
+            self.memory_manager.create_user_memories(
+                message=user_message_str,
+                user_id=user_id,
+                team_id=self.id,
             )
 
-        if self.session_summary_manager is not None:
-            tasks.append(self.session_summary_manager.acreate_session_summary(session=session))
-
-        if tasks:
-            if self.stream_intermediate_steps:
-                yield self._handle_event(
-                    create_team_memory_update_started_event(from_run_response=run_response), run_response
-                )
-
-            # Execute all tasks concurrently and handle any errors
-            try:
-                await asyncio.gather(*tasks)
-            except Exception as e:
-                log_warning(f"Error in memory/summary operation: {str(e)}")
-
-            if self.stream_intermediate_steps:
-                yield self._handle_event(
-                    create_team_memory_update_completed_event(from_run_response=run_response), run_response
-                )
+    async def _amake_memories(
+        self,
+        run_messages: RunMessages,
+        user_id: Optional[str] = None,
+    ):
+        user_message_str = (
+            run_messages.user_message.get_content_string() if run_messages.user_message is not None else None
+        )
+        if user_message_str is not None and user_message_str.strip() != "" and self.memory_manager is not None:
+            log_debug("Creating user memories.")
+            await self.memory_manager.acreate_user_memories(
+                message=user_message_str,
+                user_id=user_id,
+                team_id=self.id,
+            )
 
     def _get_response_format(self, model: Optional[Model] = None) -> Optional[Union[Dict, Type[BaseModel]]]:
         model = cast(Model, model or self.model)
@@ -3269,14 +3495,20 @@ class Team:
             log_warning("A response model is required to parse the response with a parser model")
 
     def _parse_response_with_parser_model_stream(
-        self, session: TeamSession, run_response: TeamRunOutput, stream_intermediate_steps: bool = True
+        self,
+        session: TeamSession,
+        run_response: TeamRunOutput,
+        stream_events: bool = False,
     ):
         """Parse the model response using the parser model"""
         if self.parser_model is not None:
             if self.output_schema is not None:
-                if stream_intermediate_steps:
-                    yield self._handle_event(
-                        create_team_parser_model_response_started_event(run_response), run_response
+                if stream_events:
+                    yield handle_event(  # type: ignore
+                        create_team_parser_model_response_started_event(run_response),
+                        run_response,
+                        events_to_skip=self.events_to_skip,
+                        store_events=self.store_events,
                     )
 
                 parser_model_response = ModelResponse(content="")
@@ -3295,7 +3527,7 @@ class Team:
                         full_model_response=parser_model_response,
                         model_response_event=model_response_event,
                         parse_structured_output=True,
-                        stream_intermediate_steps=stream_intermediate_steps,
+                        stream_events=stream_events,
                     )
 
                 run_response.content = parser_model_response.content
@@ -3311,23 +3543,29 @@ class Team:
                 else:
                     log_warning("Unable to parse response with parser model")
 
-                if stream_intermediate_steps:
-                    yield self._handle_event(
-                        create_team_parser_model_response_completed_event(run_response), run_response
+                if stream_events:
+                    yield handle_event(  # type: ignore
+                        create_team_parser_model_response_completed_event(run_response),
+                        run_response,
+                        events_to_skip=self.events_to_skip,
+                        store_events=self.store_events,
                     )
 
             else:
                 log_warning("A response model is required to parse the response with a parser model")
 
     async def _aparse_response_with_parser_model_stream(
-        self, session: TeamSession, run_response: TeamRunOutput, stream_intermediate_steps: bool = True
+        self, session: TeamSession, run_response: TeamRunOutput, stream_events: bool = False
     ):
         """Parse the model response using the parser model stream."""
         if self.parser_model is not None:
             if self.output_schema is not None:
-                if stream_intermediate_steps:
-                    yield self._handle_event(
-                        create_team_parser_model_response_started_event(run_response), run_response
+                if stream_events:
+                    yield handle_event(  # type: ignore
+                        create_team_parser_model_response_started_event(run_response),
+                        run_response,
+                        events_to_skip=self.events_to_skip,
+                        store_events=self.store_events,
                     )
 
                 parser_model_response = ModelResponse(content="")
@@ -3347,7 +3585,7 @@ class Team:
                         full_model_response=parser_model_response,
                         model_response_event=model_response_event,
                         parse_structured_output=True,
-                        stream_intermediate_steps=stream_intermediate_steps,
+                        stream_events=stream_events,
                     ):
                         yield event
 
@@ -3364,9 +3602,12 @@ class Team:
                 else:
                     log_warning("Unable to parse response with parser model")
 
-                if stream_intermediate_steps:
-                    yield self._handle_event(
-                        create_team_parser_model_response_completed_event(run_response), run_response
+                if stream_events:
+                    yield handle_event(  # type: ignore
+                        create_team_parser_model_response_completed_event(run_response),
+                        run_response,
+                        events_to_skip=self.events_to_skip,
+                        store_events=self.store_events,
                     )
             else:
                 log_warning("A response model is required to parse the response with a parser model")
@@ -3385,7 +3626,7 @@ class Team:
         session: TeamSession,
         run_response: TeamRunOutput,
         run_messages: RunMessages,
-        stream_intermediate_steps: bool = False,
+        stream_events: bool = False,
     ):
         """Parse the model response using the output model stream."""
         from agno.utils.events import (
@@ -3396,8 +3637,13 @@ class Team:
         if self.output_model is None:
             return
 
-        if stream_intermediate_steps:
-            yield self._handle_event(create_team_output_model_response_started_event(run_response), run_response)
+        if stream_events:
+            yield handle_event(  # type: ignore
+                create_team_output_model_response_started_event(run_response),
+                run_response,
+                events_to_skip=self.events_to_skip,
+                store_events=self.store_events,
+            )
 
         messages_for_output_model = self._get_messages_for_output_model(run_messages.messages)
         model_response = ModelResponse(content="")
@@ -3413,8 +3659,13 @@ class Team:
         # Update the TeamRunResponse content
         run_response.content = model_response.content
 
-        if stream_intermediate_steps:
-            yield self._handle_event(create_team_output_model_response_completed_event(run_response), run_response)
+        if stream_events:
+            yield handle_event(  # type: ignore
+                create_team_output_model_response_completed_event(run_response),
+                run_response,
+                events_to_skip=self.events_to_skip,
+                store_events=self.store_events,
+            )
 
         # Build a list of messages that should be added to the RunResponse
         messages_for_run_response = [m for m in run_messages.messages if m.add_to_agent_memory]
@@ -3439,7 +3690,7 @@ class Team:
         session: TeamSession,
         run_response: TeamRunOutput,
         run_messages: RunMessages,
-        stream_intermediate_steps: bool = False,
+        stream_events: bool = False,
     ):
         """Parse the model response using the output model stream."""
         from agno.utils.events import (
@@ -3450,8 +3701,13 @@ class Team:
         if self.output_model is None:
             return
 
-        if stream_intermediate_steps:
-            yield self._handle_event(create_team_output_model_response_started_event(run_response), run_response)
+        if stream_events:
+            yield handle_event(  # type: ignore
+                create_team_output_model_response_started_event(run_response),
+                run_response,
+                events_to_skip=self.events_to_skip,
+                store_events=self.store_events,
+            )
 
         messages_for_output_model = self._get_messages_for_output_model(run_messages.messages)
         model_response = ModelResponse(content="")
@@ -3468,8 +3724,13 @@ class Team:
         # Update the TeamRunResponse content
         run_response.content = model_response.content
 
-        if stream_intermediate_steps:
-            yield self._handle_event(create_team_output_model_response_completed_event(run_response), run_response)
+        if stream_events:
+            yield handle_event(  # type: ignore
+                create_team_output_model_response_completed_event(run_response),
+                run_response,
+                events_to_skip=self.events_to_skip,
+                store_events=self.store_events,
+            )
 
         # Build a list of messages that should be added to the RunResponse
         messages_for_run_response = [m for m in run_messages.messages if m.add_to_agent_memory]
@@ -3500,6 +3761,7 @@ class Team:
         input: Union[List, Dict, str, Message, BaseModel, List[Message]],
         *,
         stream: Optional[bool] = None,
+        stream_events: Optional[bool] = None,
         stream_intermediate_steps: Optional[bool] = None,
         session_id: Optional[str] = None,
         session_state: Optional[Dict[str, Any]] = None,
@@ -3540,8 +3802,15 @@ class Team:
         if stream is None:
             stream = self.stream or False
 
-        if stream_intermediate_steps is None:
-            stream_intermediate_steps = self.stream_intermediate_steps or False
+        # Considering both stream_events and stream_intermediate_steps (deprecated)
+        stream_events = stream_events or stream_intermediate_steps
+
+        # Can't stream events if streaming is disabled
+        if stream is False:
+            stream_events = False
+
+        if stream_events is None:
+            stream_events = False if self.stream_events is None else self.stream_events
 
         if stream:
             print_response_stream(
@@ -3560,7 +3829,7 @@ class Team:
                 videos=videos,
                 files=files,
                 markdown=markdown,
-                stream_intermediate_steps=stream_intermediate_steps,
+                stream_events=stream_events,
                 knowledge_filters=knowledge_filters,
                 add_history_to_context=add_history_to_context,
                 dependencies=dependencies,
@@ -3602,6 +3871,7 @@ class Team:
         input: Union[List, Dict, str, Message, BaseModel, List[Message]],
         *,
         stream: Optional[bool] = None,
+        stream_events: Optional[bool] = None,
         stream_intermediate_steps: Optional[bool] = None,
         session_id: Optional[str] = None,
         session_state: Optional[Dict[str, Any]] = None,
@@ -3637,8 +3907,15 @@ class Team:
         if stream is None:
             stream = self.stream or False
 
-        if stream_intermediate_steps is None:
-            stream_intermediate_steps = self.stream_intermediate_steps or False
+        # Considering both stream_events and stream_intermediate_steps (deprecated)
+        stream_events = stream_events or stream_intermediate_steps
+
+        # Can't stream events if streaming is disabled
+        if stream is False:
+            stream_events = False
+
+        if stream_events is None:
+            stream_events = False if self.stream_events is None else self.stream_events
 
         if stream:
             await aprint_response_stream(
@@ -3657,7 +3934,7 @@ class Team:
                 videos=videos,
                 files=files,
                 markdown=markdown,
-                stream_intermediate_steps=stream_intermediate_steps,
+                stream_events=stream_events,
                 knowledge_filters=knowledge_filters,
                 add_history_to_context=add_history_to_context,
                 dependencies=dependencies,
@@ -3704,88 +3981,6 @@ class Team:
                     return member.name or entity_id
         return entity_id
 
-    def _scrub_media_from_run_output(self, run_response: TeamRunOutput) -> None:
-        """
-        Completely remove all media from RunOutput when store_media=False.
-        This includes media in input, output artifacts, and all messages.
-        """
-        # 1. Scrub RunInput media
-        if run_response.input is not None:
-            run_response.input.images = []
-            run_response.input.videos = []
-            run_response.input.audios = []
-            run_response.input.files = []
-
-        # 3. Scrub media from all messages
-        if run_response.messages:
-            for message in run_response.messages:
-                self._scrub_media_from_message(message)
-
-        # 4. Scrub media from additional_input messages if any
-        if run_response.additional_input:
-            for message in run_response.additional_input:
-                self._scrub_media_from_message(message)
-
-        # 5. Scrub media from reasoning_messages if any
-        if run_response.reasoning_messages:
-            for message in run_response.reasoning_messages:
-                self._scrub_media_from_message(message)
-
-    def _scrub_media_from_message(self, message: Message) -> None:
-        """Remove all media from a Message object."""
-        # Input media
-        message.images = None
-        message.videos = None
-        message.audio = None
-        message.files = None
-
-        # Output media
-        message.audio_output = None
-        message.image_output = None
-        message.video_output = None
-
-    def _scrub_tool_results_from_run_output(self, run_response: TeamRunOutput) -> None:
-        """
-        Remove all tool-related data from RunOutput when store_tool_messages=False.
-        This removes both the tool call and its corresponding result to maintain API consistency.
-        """
-        if not run_response.messages:
-            return
-
-        # Step 1: Collect all tool_call_ids from tool result messages
-        tool_call_ids_to_remove = set()
-        for message in run_response.messages:
-            if message.role == "tool" and message.tool_call_id:
-                tool_call_ids_to_remove.add(message.tool_call_id)
-
-        # Step 2: Remove tool result messages (role="tool")
-        run_response.messages = [msg for msg in run_response.messages if msg.role != "tool"]
-
-        # Step 3: Remove assistant messages that made those tool calls
-        filtered_messages = []
-        for message in run_response.messages:
-            # Check if this assistant message made any of the tool calls we're removing
-            should_remove = False
-            if message.role == "assistant" and message.tool_calls:
-                for tool_call in message.tool_calls:
-                    if tool_call.get("id") in tool_call_ids_to_remove:
-                        should_remove = True
-                        break
-
-            if not should_remove:
-                filtered_messages.append(message)
-
-        run_response.messages = filtered_messages
-
-    def _scrub_history_messages_from_run_output(self, run_response: TeamRunOutput) -> None:
-        """
-        Remove all history messages from TeamRunOutput when store_history_messages=False.
-        This removes messages that were loaded from the team's memory.
-        """
-        # Remove messages with from_history=True
-        if run_response.messages:
-            run_response.messages = [msg for msg in run_response.messages if not msg.from_history]
-
     def _scrub_run_output_for_storage(self, run_response: TeamRunOutput) -> bool:
         """
         Scrub run output based on storage flags before persisting to database.
@@ -3794,15 +3989,15 @@ class Team:
         scrubbed = False
 
         if not self.store_media:
-            self._scrub_media_from_run_output(run_response)
+            scrub_media_from_run_output(run_response)
             scrubbed = True
 
         if not self.store_tool_messages:
-            self._scrub_tool_results_from_run_output(run_response)
+            scrub_tool_results_from_run_output(run_response)
             scrubbed = True
 
         if not self.store_history_messages:
-            self._scrub_history_messages_from_run_output(run_response)
+            scrub_history_messages_from_run_output(run_response)
             scrubbed = True
 
         return scrubbed
@@ -3959,32 +4154,42 @@ class Team:
     # Helpers
     ###########################################################################
 
-    def _handle_reasoning(self, run_response: TeamRunOutput, run_messages: RunMessages) -> None:
+    def _handle_reasoning(self, run_response: TeamRunOutput, run_messages: RunMessages):
         if self.reasoning or self.reasoning_model is not None:
-            reasoning_generator = self._reason(run_response=run_response, run_messages=run_messages)
+            reasoning_generator = self._reason(
+                run_response=run_response, run_messages=run_messages, stream_events=False
+            )
 
             # Consume the generator without yielding
             deque(reasoning_generator, maxlen=0)
 
     def _handle_reasoning_stream(
-        self, run_response: TeamRunOutput, run_messages: RunMessages
+        self, run_response: TeamRunOutput, run_messages: RunMessages, stream_events: bool
     ) -> Iterator[TeamRunOutputEvent]:
         if self.reasoning or self.reasoning_model is not None:
-            reasoning_generator = self._reason(run_response=run_response, run_messages=run_messages)
+            reasoning_generator = self._reason(
+                run_response=run_response,
+                run_messages=run_messages,
+                stream_events=stream_events,
+            )
             yield from reasoning_generator
 
     async def _ahandle_reasoning(self, run_response: TeamRunOutput, run_messages: RunMessages) -> None:
         if self.reasoning or self.reasoning_model is not None:
-            reason_generator = self._areason(run_response=run_response, run_messages=run_messages)
+            reason_generator = self._areason(run_response=run_response, run_messages=run_messages, stream_events=False)
             # Consume the generator without yielding
             async for _ in reason_generator:
                 pass
 
     async def _ahandle_reasoning_stream(
-        self, run_response: TeamRunOutput, run_messages: RunMessages
+        self, run_response: TeamRunOutput, run_messages: RunMessages, stream_events: bool
     ) -> AsyncIterator[TeamRunOutputEvent]:
         if self.reasoning or self.reasoning_model is not None:
-            reason_generator = self._areason(run_response=run_response, run_messages=run_messages)
+            reason_generator = self._areason(
+                run_response=run_response,
+                run_messages=run_messages,
+                stream_events=stream_events,
+            )
             async for item in reason_generator:
                 yield item
 
@@ -4062,9 +4267,15 @@ class Team:
         self,
         run_response: TeamRunOutput,
         run_messages: RunMessages,
+        stream_events: bool,
     ) -> Iterator[TeamRunOutputEvent]:
-        if self.stream_intermediate_steps:
-            yield self._handle_event(create_team_reasoning_started_event(from_run_response=run_response), run_response)
+        if stream_events:
+            yield handle_event(  # type: ignore
+                create_team_reasoning_started_event(from_run_response=run_response),
+                run_response,
+                events_to_skip=self.events_to_skip,
+                store_events=self.store_events,
+            )
 
         use_default_reasoning = False
 
@@ -4185,14 +4396,16 @@ class Team:
                     reasoning_steps=[ReasoningStep(result=reasoning_message.content)],
                     reasoning_agent_messages=[reasoning_message],
                 )
-                if self.stream_intermediate_steps:
-                    yield self._handle_event(
+                if stream_events:
+                    yield handle_event(  # type: ignore
                         create_team_reasoning_completed_event(
                             from_run_response=run_response,
                             content=ReasoningSteps(reasoning_steps=[ReasoningStep(result=reasoning_message.content)]),
                             content_type=ReasoningSteps.__name__,
                         ),
                         run_response,
+                        events_to_skip=self.events_to_skip,
+                        store_events=self.store_events,
                     )
             else:
                 log_warning(
@@ -4270,19 +4483,21 @@ class Team:
                     reasoning_steps: List[ReasoningStep] = reasoning_agent_response.content.reasoning_steps
                     all_reasoning_steps.extend(reasoning_steps)
                     # Yield reasoning steps
-                    if self.stream_intermediate_steps:
+                    if stream_events:
                         for reasoning_step in reasoning_steps:
                             updated_reasoning_content = self._format_reasoning_step_content(
                                 run_response, reasoning_step
                             )
 
-                            yield self._handle_event(
+                            yield handle_event(  # type: ignore
                                 create_team_reasoning_step_event(
                                     from_run_response=run_response,
                                     reasoning_step=reasoning_step,
                                     reasoning_content=updated_reasoning_content,
                                 ),
                                 run_response,
+                                events_to_skip=self.events_to_skip,
+                                store_events=self.store_events,
                             )
 
                     # Find the index of the first assistant message
@@ -4318,23 +4533,31 @@ class Team:
             )
 
             # Yield the final reasoning completed event
-            if self.stream_intermediate_steps:
-                yield self._handle_event(
+            if stream_events:
+                yield handle_event(  # type: ignore
                     create_team_reasoning_completed_event(
                         from_run_response=run_response,
                         content=ReasoningSteps(reasoning_steps=all_reasoning_steps),
                         content_type=ReasoningSteps.__name__,
                     ),
                     run_response,
+                    events_to_skip=self.events_to_skip,
+                    store_events=self.store_events,
                 )
 
     async def _areason(
         self,
         run_response: TeamRunOutput,
         run_messages: RunMessages,
+        stream_events: bool,
     ) -> AsyncIterator[TeamRunOutputEvent]:
-        if self.stream_intermediate_steps:
-            yield self._handle_event(create_team_reasoning_started_event(from_run_response=run_response), run_response)
+        if stream_events:
+            yield handle_event(  # type: ignore
+                create_team_reasoning_started_event(from_run_response=run_response),
+                run_response,
+                events_to_skip=self.events_to_skip,
+                store_events=self.store_events,
+            )
 
         use_default_reasoning = False
 
@@ -4454,14 +4677,16 @@ class Team:
                     reasoning_steps=[ReasoningStep(result=reasoning_message.content)],
                     reasoning_agent_messages=[reasoning_message],
                 )
-                if self.stream_intermediate_steps:
-                    yield self._handle_event(
+                if stream_events:
+                    yield handle_event(  # type: ignore
                         create_team_reasoning_completed_event(
                             from_run_response=run_response,
                             content=ReasoningSteps(reasoning_steps=[ReasoningStep(result=reasoning_message.content)]),
                             content_type=ReasoningSteps.__name__,
                         ),
                         run_response,
+                        events_to_skip=self.events_to_skip,
+                        store_events=self.store_events,
                     )
             else:
                 log_warning(
@@ -4538,19 +4763,21 @@ class Team:
                     reasoning_steps: List[ReasoningStep] = reasoning_agent_response.content.reasoning_steps
                     all_reasoning_steps.extend(reasoning_steps)
                     # Yield reasoning steps
-                    if self.stream_intermediate_steps:
+                    if stream_events:
                         for reasoning_step in reasoning_steps:
                             updated_reasoning_content = self._format_reasoning_step_content(
                                 run_response, reasoning_step
                             )
 
-                            yield self._handle_event(
+                            yield handle_event(  # type: ignore
                                 create_team_reasoning_step_event(
                                     from_run_response=run_response,
                                     reasoning_step=reasoning_step,
                                     reasoning_content=updated_reasoning_content,
                                 ),
                                 run_response,
+                                events_to_skip=self.events_to_skip,
+                                store_events=self.store_events,
                             )
 
                     # Find the index of the first assistant message
@@ -4586,14 +4813,16 @@ class Team:
             )
 
             # Yield the final reasoning completed event
-            if self.stream_intermediate_steps:
-                yield self._handle_event(
+            if stream_events:
+                yield handle_event(  # type: ignore  # type: ignore
                     create_team_reasoning_completed_event(
                         from_run_response=run_response,
                         content=ReasoningSteps(reasoning_steps=all_reasoning_steps),
                         content_type=ReasoningSteps.__name__,
                     ),
                     run_response,
+                    events_to_skip=self.events_to_skip,
+                    store_events=self.store_events,
                 )
 
     def _resolve_run_dependencies(self, dependencies: Optional[Dict[str, Any]] = None) -> None:
@@ -4641,137 +4870,6 @@ class Team:
             except Exception as e:
                 log_warning(f"Failed to resolve context for '{key}': {e}")
 
-    def _collect_joint_images(
-        self,
-        run_input: Optional[TeamRunInput] = None,
-        session: Optional[TeamSession] = None,
-    ) -> Optional[Sequence[Image]]:
-        """Collect images from input, session history, and current run response."""
-        joint_images: List[Image] = []
-
-        # 1. Add images from current input
-        if run_input and run_input.images:
-            joint_images.extend(run_input.images)
-            log_debug(f"Added {len(run_input.images)} input images to joint list")
-
-        # 2. Add images from session history (from both input and generated sources)
-        try:
-            if session and session.runs:
-                for historical_run in session.runs:
-                    # Add generated images from previous runs
-                    if historical_run.images:
-                        joint_images.extend(historical_run.images)
-                        log_debug(
-                            f"Added {len(historical_run.images)} generated images from historical run {historical_run.run_id}"
-                        )
-
-                    # Add input images from previous runs
-                    if historical_run.input and historical_run.input.images:
-                        joint_images.extend(historical_run.input.images)
-                        log_debug(
-                            f"Added {len(historical_run.input.images)} input images from historical run {historical_run.run_id}"
-                        )
-        except Exception as e:
-            log_debug(f"Could not access session history for images: {e}")
-
-        if joint_images:
-            log_debug(f"Images Available to Model: {len(joint_images)} images")
-        return joint_images if joint_images else None
-
-    def _collect_joint_videos(
-        self,
-        run_input: Optional[TeamRunInput] = None,
-        session: Optional[TeamSession] = None,
-    ) -> Optional[Sequence[Video]]:
-        """Collect videos from input, session history, and current run response."""
-        joint_videos: List[Video] = []
-
-        # 1. Add videos from current input
-        if run_input and run_input.videos:
-            joint_videos.extend(run_input.videos)
-            log_debug(f"Added {len(run_input.videos)} input videos to joint list")
-
-        # 2. Add videos from session history (from both input and generated sources)
-        try:
-            if session and session.runs:
-                for historical_run in session.runs:
-                    # Add generated videos from previous runs
-                    if historical_run.videos:
-                        joint_videos.extend(historical_run.videos)
-                        log_debug(
-                            f"Added {len(historical_run.videos)} generated videos from historical run {historical_run.run_id}"
-                        )
-
-                    # Add input videos from previous runs
-                    if historical_run.input and historical_run.input.videos:
-                        joint_videos.extend(historical_run.input.videos)
-                        log_debug(
-                            f"Added {len(historical_run.input.videos)} input videos from historical run {historical_run.run_id}"
-                        )
-        except Exception as e:
-            log_debug(f"Could not access session history for videos: {e}")
-
-        if joint_videos:
-            log_debug(f"Videos Available to Model: {len(joint_videos)} videos")
-        return joint_videos if joint_videos else None
-
-    def _collect_joint_audios(
-        self,
-        run_input: Optional[TeamRunInput] = None,
-        session: Optional[TeamSession] = None,
-    ) -> Optional[Sequence[Audio]]:
-        """Collect audios from input, session history, and current run response."""
-        joint_audios: List[Audio] = []
-
-        # 1. Add audios from current input
-        if run_input and run_input.audios:
-            joint_audios.extend(run_input.audios)
-            log_debug(f"Added {len(run_input.audios)} input audios to joint list")
-
-        # 2. Add audios from session history (from both input and generated sources)
-        try:
-            if session and session.runs:
-                for historical_run in session.runs:
-                    # Add generated audios from previous runs
-                    if historical_run.audio:
-                        joint_audios.extend(historical_run.audio)
-                        log_debug(
-                            f"Added {len(historical_run.audio)} generated audios from historical run {historical_run.run_id}"
-                        )
-
-                    # Add input audios from previous runs
-                    if historical_run.input and historical_run.input.audios:
-                        joint_audios.extend(historical_run.input.audios)
-                        log_debug(
-                            f"Added {len(historical_run.input.audios)} input audios from historical run {historical_run.run_id}"
-                        )
-        except Exception as e:
-            log_debug(f"Could not access session history for audios: {e}")
-
-        if joint_audios:
-            log_debug(f"Audios Available to Model: {len(joint_audios)} audios")
-        return joint_audios if joint_audios else None
-
-    def _collect_joint_files(
-        self,
-        run_input: Optional[TeamRunInput] = None,
-    ) -> Optional[Sequence[File]]:
-        """Collect files from input and session history."""
-        from agno.utils.log import log_debug
-
-        joint_files: List[File] = []
-
-        # 1. Add files from current input
-        if run_input and run_input.files:
-            joint_files.extend(run_input.files)
-
-        # TODO: Files aren't stored in session history yet and dont have a FileArtifact
-
-        if joint_files:
-            log_debug(f"Files Available to Model: {len(joint_files)} files")
-
-        return joint_files if joint_files else None
-
     def determine_tools_for_model(
         self,
         model: Model,
@@ -4802,14 +4900,14 @@ class Team:
             for tool in self.tools:
                 _tools.append(tool)
 
-        if self.read_team_history:
-            _tools.append(self._get_team_history_function(session=session))
+        if self.read_chat_history:
+            _tools.append(self._get_chat_history_function(session=session, async_mode=async_mode))
 
         if self.memory_manager is not None and self.enable_agentic_memory:
             _tools.append(self._get_update_user_memory_function(user_id=user_id, async_mode=async_mode))
 
         if self.enable_agentic_state:
-            _tools.append(self.update_session_state)
+            _tools.append(Function(name="update_session_state", entrypoint=self._update_session_state_tool))
 
         if self.search_session_history:
             _tools.append(
@@ -4848,7 +4946,7 @@ class Team:
 
         if self.members:
             # Get the user message if we are using the input directly
-            user_message = None
+            user_message_content = None
             if self.determine_input_for_members is False:
                 user_message = self._get_user_message(
                     run_response=run_response,
@@ -4863,16 +4961,17 @@ class Team:
                     add_dependencies_to_context=add_dependencies_to_context,
                     metadata=metadata,
                 )
+                user_message_content = user_message.content if user_message is not None else None
 
             delegate_task_func = self._get_delegate_task_function(
                 run_response=run_response,
                 session=session,
                 session_state=session_state,
                 team_run_context=team_run_context,
-                input=user_message,
+                input=user_message_content,
                 user_id=user_id,
                 stream=self.stream or False,
-                stream_intermediate_steps=self.stream_intermediate_steps,
+                stream_events=self.stream_events or False,
                 async_mode=async_mode,
                 images=images,  # type: ignore
                 videos=videos,  # type: ignore
@@ -4983,10 +5082,10 @@ class Team:
 
             if needs_media:
                 # Only collect media if functions actually need them
-                joint_images = self._collect_joint_images(run_response.input, session)
-                joint_files = self._collect_joint_files(run_response.input)
-                joint_audios = self._collect_joint_audios(run_response.input, session)
-                joint_videos = self._collect_joint_videos(run_response.input, session)
+                joint_images = collect_joint_images(run_response.input, session)  # type: ignore
+                joint_files = collect_joint_files(run_response.input)  # type: ignore
+                joint_audios = collect_joint_audios(run_response.input, session)  # type: ignore
+                joint_videos = collect_joint_videos(run_response.input, session)  # type: ignore
 
                 for func in self._functions_for_model.values():
                     func._images = joint_images
@@ -5183,12 +5282,11 @@ class Team:
                     "- You cannot use a member tool directly. You can only delegate tasks to members.\n"
                     "- When you delegate a task to another member, make sure to include:\n"
                     "  - member_id (str): The ID of the member to delegate the task to. Use only the ID of the member, not the ID of the team followed by the ID of the member.\n"
-                    "  - task_description (str): A clear description of the task.\n"
-                    "  - expected_output (str): The expected output.\n"
+                    "  - task (str): A clear description of the task. Determine the best way to describe the task to the member.\n"
                     "- You can delegate tasks to multiple members at once.\n"
                     "- You must always analyze the responses from members before responding to the user.\n"
                     "- After analyzing the responses from the members, if you feel the task has been completed, you can stop and respond to the user.\n"
-                    "- If you are not satisfied with the responses from the members, you should re-assign the task.\n"
+                    "- If you are NOT satisfied with the responses from the members, you should re-assign the task to a different member.\n"
                     "- For simple greetings, thanks, or questions about the team itself, you should respond directly.\n"
                     "- For all work requests, tasks, or questions requiring expertise, route to appropriate team members.\n"
                 )
@@ -5477,8 +5575,7 @@ class Team:
                 "- You cannot use a member tool directly. You can only delegate tasks to members.\n"
                 "- When you delegate a task to another member, make sure to include:\n"
                 "  - member_id (str): The ID of the member to delegate the task to. Use only the ID of the member, not the ID of the team followed by the ID of the member.\n"
-                "  - task_description (str): A clear description of the task.\n"
-                "  - expected_output (str): The expected output.\n"
+                "  - task (str): A clear description of the task.\n"
                 "- You can delegate tasks to multiple members at once.\n"
                 "- You must always analyze the responses from members before responding to the user.\n"
                 "- After analyzing the responses from the members, if you feel the task has been completed, you can stop and respond to the user.\n"
@@ -5733,7 +5830,6 @@ class Team:
                 run_messages.messages += history_copy
 
         # 5. Add user message to run_messages (message second as per Dirk's requirement)
-        user_message: Optional[Message] = None
         # 5.1 Build user message if message is None, str or list
         user_message = self._get_user_message(
             run_response=run_response,
@@ -5861,7 +5957,6 @@ class Team:
                 run_messages.messages += history_copy
 
         # 5. Add user message to run_messages (message second as per Dirk's requirement)
-        user_message: Optional[Message] = None
         # 5.1 Build user message if message is None, str or list
         user_message = self._get_user_message(
             run_response=run_response,
@@ -6305,10 +6400,15 @@ class Team:
         """Get information about the members of the team, including their IDs, names, and roles."""
         return self.get_members_system_message_content(indent=0)
 
-    def _get_team_history_function(self, session: TeamSession) -> Callable:
-        def get_team_history(num_chats: Optional[int] = None) -> str:
+    def _get_chat_history_function(self, session: TeamSession, async_mode: bool = False):
+        def get_chat_history(num_chats: Optional[int] = None) -> str:
             """
-            Use this function to get the team chat history.
+            Use this function to get the team chat history in reverse chronological order.
+            Leave the num_chats parameter blank to get the entire chat history.
+            Example:
+                - To get the last chat, use num_chats=1
+                - To get the last 5 chats, use num_chats=5
+                - To get all chats, leave num_chats blank
 
             Args:
                 num_chats: The number of chats to return.
@@ -6317,12 +6417,42 @@ class Team:
 
             Returns:
                 str: A JSON string containing a list of dictionaries representing the team chat history.
+            """
+            import json
+
+            history: List[Dict[str, Any]] = []
+
+            all_chats = session.get_messages_from_last_n_runs(
+                team_id=self.id,
+            )
+
+            if len(all_chats) == 0:
+                return ""
+
+            for chat in all_chats[::-1]:  # type: ignore
+                history.insert(0, chat.to_dict())  # type: ignore
+
+            if num_chats is not None:
+                history = history[:num_chats]
+
+            return json.dumps(history)
 
+        async def aget_chat_history(num_chats: Optional[int] = None) -> str:
+            """
+            Use this function to get the team chat history in reverse chronological order.
+            Leave the num_chats parameter blank to get the entire chat history.
             Example:
                 - To get the last chat, use num_chats=1
                 - To get the last 5 chats, use num_chats=5
-                - To get all chats, use num_chats=None
-                - To get the first chat, use num_chats=None and take the first message
+                - To get all chats, leave num_chats blank
+
+            Args:
+                num_chats: The number of chats to return.
+                    Each chat contains 2 messages. One from the team and one from the user.
+                    Default: None
+
+            Returns:
+                str: A JSON string containing a list of dictionaries representing the team chat history.
             """
             import json
 
@@ -6343,9 +6473,13 @@ class Team:
 
             return json.dumps(history)
 
-        return get_team_history
+        if async_mode:
+            get_chat_history_func = aget_chat_history
+        else:
+            get_chat_history_func = get_chat_history  # type: ignore
+        return Function.from_callable(get_chat_history_func, name="get_chat_history")
 
-    def update_session_state(self, session_state, session_state_updates: dict) -> str:
+    def _update_session_state_tool(self, session_state, session_state_updates: dict) -> str:
         """
         Update the shared session state.  Provide any updates as a dictionary of key-value pairs.
         Example:
@@ -6361,7 +6495,7 @@ class Team:
 
     def _get_previous_sessions_messages_function(
         self, num_history_sessions: Optional[int] = 2, user_id: Optional[str] = None
-    ) -> Callable:
+    ):
         """Factory function to create a get_previous_session_messages function.
 
         Args:
@@ -6477,9 +6611,9 @@ class Team:
             return json.dumps([msg.to_dict() for msg in all_messages]) if all_messages else "No history found"
 
         if self._has_async_db():
-            return aget_previous_session_messages
+            return Function.from_callable(aget_previous_session_messages, name="get_previous_session_messages")
         else:
-            return get_previous_session_messages
+            return Function.from_callable(get_previous_session_messages, name="get_previous_session_messages")
 
     def _get_history_for_member_agent(self, session: TeamSession, member_agent: Union[Agent, "Team"]) -> List[Message]:
         from copy import deepcopy
@@ -6514,7 +6648,12 @@ class Team:
         return []
 
     def _determine_team_member_interactions(
-        self, team_run_context: Dict[str, Any], images: List[Image], videos: List[Video], audio: List[Audio]
+        self,
+        team_run_context: Dict[str, Any],
+        images: List[Image],
+        videos: List[Video],
+        audio: List[Audio],
+        files: List[File],
     ) -> Optional[str]:
         team_member_interactions_str = None
         if self.share_member_interactions:
@@ -6525,6 +6664,8 @@ class Team:
                 videos.extend(context_videos)
             if context_audio := self._get_team_run_context_audio(team_run_context=team_run_context):  # type: ignore
                 audio.extend(context_audio)
+            if context_files := self._get_team_run_context_files(team_run_context=team_run_context):  # type: ignore
+                files.extend(context_files)
         return team_member_interactions_str
 
     def _find_member_by_id(self, member_id: str) -> Optional[Tuple[int, Union[Agent, "Team"]]]:
@@ -6562,9 +6703,9 @@ class Team:
         team_run_context: Dict[str, Any],
         user_id: Optional[str] = None,
         stream: bool = False,
-        stream_intermediate_steps: bool = False,
+        stream_events: bool = False,
         async_mode: bool = False,
-        input: Optional[Message] = None,  # Used for determine_input_for_memberss=False
+        input: Optional[str] = None,  # Used for determine_input_for_members=False
         images: Optional[List[Image]] = None,
         videos: Optional[List[Video]] = None,
         audio: Optional[List[Audio]] = None,
@@ -6586,54 +6727,54 @@ class Team:
         if not files:
             files = []
 
-        def _setup_delegate_task_to_member(
-            member_agent: Union[Agent, "Team"], task_description: str, expected_output: Optional[str] = None
-        ):
+        def _setup_delegate_task_to_member(member_agent: Union[Agent, "Team"], task_description: str):
             # 1. Initialize the member agent
             self._initialize_member(member_agent)
 
-            # 2. Determine team context to send
+            # 2. Handle respond_directly nuances
+            if self.respond_directly:
+                # Since we return the response directly from the member agent, we need to set the output schema from the team down.
+                if not member_agent.output_schema and self.output_schema:
+                    member_agent.output_schema = self.output_schema
+
+                # If the member will produce structured output, we need to parse the response
+                if member_agent.output_schema is not None:
+                    self._member_response_model = member_agent.output_schema
+
+            # 3. Handle enable_agentic_knowledge_filters on the member agent
+            if self.enable_agentic_knowledge_filters and not member_agent.enable_agentic_knowledge_filters:
+                member_agent.enable_agentic_knowledge_filters = self.enable_agentic_knowledge_filters
+
+            # 4. Determine team context to send
             team_member_interactions_str = self._determine_team_member_interactions(
-                team_run_context, images, videos, audio
+                team_run_context, images=images, videos=videos, audio=audio, files=files
             )
 
-            member_agent_task: Union[str, Message]
+            # 5. Get the team history
+            team_history_str = None
+            if self.add_team_history_to_members and session:
+                team_history_str = session.get_team_history_context(num_runs=self.num_team_history_runs)
 
-            # 3. Create the member agent task or use the input directly
+            # 6. Create the member agent task or use the input directly
             if self.determine_input_for_members is False:
                 member_agent_task = input  # type: ignore
             else:
-                # Don't override the expected output of a member agent
-                if member_agent.expected_output is not None:
-                    expected_output = None
+                member_agent_task = task_description
 
+            if team_history_str or team_member_interactions_str:
                 member_agent_task = format_member_agent_task(  # type: ignore
-                    task_description, expected_output, team_member_interactions_str
+                    task_description=member_agent_task or "",
+                    team_member_interactions_str=team_member_interactions_str,
+                    team_history_str=team_history_str,
                 )
 
-            # 4. Add history for the member if enabled (because we won't load the session for the member, so history won't be loaded automatically)
+            # 7. Add member-level history for the member if enabled (because we won't load the session for the member, so history won't be loaded automatically)
             history = None
-            if member_agent.add_history_to_context or add_history_to_context:
+            if member_agent.add_history_to_context:
                 history = self._get_history_for_member_agent(session, member_agent)
                 if history:
                     if isinstance(member_agent_task, str):
                         history.append(Message(role="user", content=member_agent_task))
-                    else:
-                        history.append(member_agent_task)
-
-            # 5. Handle respond_directly
-            if self.respond_directly:
-                # Since we return the response directly from the member agent, we need to set the output schema from the team down.
-                if not member_agent.output_schema and self.output_schema:
-                    member_agent.output_schema = self.output_schema
-
-                # If the member will produce structured output, we need to parse the response
-                if member_agent.output_schema is not None:
-                    self._member_response_model = member_agent.output_schema
-
-            # 6. Handle enable_agentic_knowledge_filters on the member agent
-            if self.enable_agentic_knowledge_filters and not member_agent.enable_agentic_knowledge_filters:
-                member_agent.enable_agentic_knowledge_filters = self.enable_agentic_knowledge_filters
 
             return member_agent_task, history
 
@@ -6692,28 +6833,28 @@ class Team:
                 self._update_team_media(member_agent_run_response)  # type: ignore
 
         def delegate_task_to_member(
-            member_id: str, task_description: str, expected_output: Optional[str] = None
+            member_id: str, task: str
         ) -> Iterator[Union[RunOutputEvent, TeamRunOutputEvent, str]]:
             """Use this function to delegate a task to the selected team member.
             You must provide a clear and concise description of the task the member should achieve AND the expected output.
 
             Args:
                 member_id (str): The ID of the member to delegate the task to. Use only the ID of the member, not the ID of the team followed by the ID of the member.
-                task_description (str): A clear and concise description of the task the member should achieve.
-                expected_output (str, optional): The expected output from the member (optional).
+                task (str): A clear and concise description of the task the member should achieve.
             Returns:
                 str: The result of the delegated task.
             """
 
             # Find the member agent using the helper function
             result = self._find_member_by_id(member_id)
-            history = None
             if result is None:
                 yield f"Member with ID {member_id} not found in the team or any subteams. Please choose the correct member from the list of members:\n\n{self.get_members_system_message_content(indent=0)}"
                 return
 
             _, member_agent = result
-            member_agent_task, history = _setup_delegate_task_to_member(member_agent, task_description, expected_output)
+            member_agent_task, history = _setup_delegate_task_to_member(
+                member_agent=member_agent, task_description=task
+            )
 
             # Make sure for the member agent, we are using the agent logger
             use_agent_logger()
@@ -6731,7 +6872,7 @@ class Team:
                     audio=audio,
                     files=files,
                     stream=True,
-                    stream_intermediate_steps=stream_intermediate_steps,
+                    stream_events=stream_events,
                     debug_mode=debug_mode,
                     dependencies=dependencies,
                     add_dependencies_to_context=add_dependencies_to_context,
@@ -6818,28 +6959,28 @@ class Team:
             )
 
         async def adelegate_task_to_member(
-            member_id: str, task_description: str, expected_output: Optional[str] = None
+            member_id: str, task: str
         ) -> AsyncIterator[Union[RunOutputEvent, TeamRunOutputEvent, str]]:
             """Use this function to delegate a task to the selected team member.
             You must provide a clear and concise description of the task the member should achieve AND the expected output.
 
             Args:
                 member_id (str): The ID of the member to delegate the task to. Use only the ID of the member, not the ID of the team followed by the ID of the member.
-                task_description (str): A clear and concise description of the task the member should achieve.
-                expected_output (str, optional): The expected output from the member (optional).
+                task (str): A clear and concise description of the task the member should achieve.
             Returns:
                 str: The result of the delegated task.
             """
 
             # Find the member agent using the helper function
             result = self._find_member_by_id(member_id)
-            history = None
             if result is None:
                 yield f"Member with ID {member_id} not found in the team or any subteams. Please choose the correct member from the list of members:\n\n{self.get_members_system_message_content(indent=0)}"
                 return
 
             _, member_agent = result
-            member_agent_task, history = _setup_delegate_task_to_member(member_agent, task_description, expected_output)
+            member_agent_task, history = _setup_delegate_task_to_member(
+                member_agent=member_agent, task_description=task
+            )
 
             # Make sure for the member agent, we are using the agent logger
             use_agent_logger()
@@ -6857,7 +6998,7 @@ class Team:
                     audio=audio,
                     files=files,
                     stream=True,
-                    stream_intermediate_steps=stream_intermediate_steps,
+                    stream_events=stream_events,
                     debug_mode=debug_mode,
                     dependencies=dependencies,
                     add_dependencies_to_context=add_dependencies_to_context,
@@ -6940,16 +7081,13 @@ class Team:
             )
 
         # When the task should be delegated to all members
-        def delegate_task_to_members(
-            task_description: str, expected_output: Optional[str] = None
-        ) -> Iterator[Union[RunOutputEvent, TeamRunOutputEvent, str]]:
+        def delegate_task_to_members(task: str) -> Iterator[Union[RunOutputEvent, TeamRunOutputEvent, str]]:
             """
             Use this function to delegate a task to all the member agents and return a response.
             You must provide a clear and concise description of the task the member should achieve AND the expected output.
 
             Args:
-                task_description (str): A clear and concise description of the task to send to member agents.
-                expected_output (str, optional): The expected output from the member agents (optional).
+                task (str): A clear and concise description of the task to send to member agents.
             Returns:
                 str: The result of the delegated task.
             """
@@ -6957,7 +7095,7 @@ class Team:
             # Run all the members sequentially
             for _, member_agent in enumerate(self.members):
                 member_agent_task, history = _setup_delegate_task_to_member(
-                    member_agent, task_description, expected_output
+                    member_agent=member_agent, task_description=task
                 )
 
                 member_session_state_copy = copy(session_state)
@@ -6973,7 +7111,7 @@ class Team:
                         audio=audio,
                         files=files,
                         stream=True,
-                        stream_intermediate_steps=stream_intermediate_steps,
+                        stream_events=stream_events,
                         knowledge_filters=knowledge_filters
                         if not member_agent.knowledge_filters and member_agent.knowledge
                         else None,
@@ -7055,15 +7193,12 @@ class Team:
             use_team_logger()
 
         # When the task should be delegated to all members
-        async def adelegate_task_to_members(
-            task_description: str, expected_output: Optional[str] = None
-        ) -> AsyncIterator[Union[RunOutputEvent, TeamRunOutputEvent, str]]:
+        async def adelegate_task_to_members(task: str) -> AsyncIterator[Union[RunOutputEvent, TeamRunOutputEvent, str]]:
             """Use this function to delegate a task to all the member agents and return a response.
-            You must provide a clear and concise description of the task to send to member agents AND the expected output.
+            You must provide a clear and concise description of the task to send to member agents.
 
             Args:
-                task_description (str): A clear and concise description of the task to send to member agents.
-                expected_output (str, optional): The expected output from the member agents (optional).
+                task (str): A clear and concise description of the task to send to member agents.
             Returns:
                 str: The result of the delegated task.
             """
@@ -7075,8 +7210,8 @@ class Team:
 
                 async def stream_member(agent: Union[Agent, "Team"]) -> None:
                     member_agent_task, history = _setup_delegate_task_to_member(
-                        agent, task_description, expected_output
-                    )
+                        member_agent=agent, task_description=task
+                    )  # type: ignore
                     member_session_state_copy = copy(session_state)
 
                     member_stream = agent.arun(  # type: ignore
@@ -7089,7 +7224,7 @@ class Team:
                         audio=audio,
                         files=files,
                         stream=True,
-                        stream_intermediate_steps=stream_intermediate_steps,
+                        stream_events=stream_events,
                         debug_mode=debug_mode,
                         knowledge_filters=knowledge_filters
                         if not member_agent.knowledge_filters and member_agent.knowledge
@@ -7150,7 +7285,7 @@ class Team:
                 for member_agent_index, member_agent in enumerate(self.members):
                     current_agent = member_agent
                     member_agent_task, history = _setup_delegate_task_to_member(
-                        current_agent, task_description, expected_output
+                        member_agent=current_agent, task_description=task
                     )
 
                     async def run_member_agent(agent=current_agent) -> str:
@@ -7166,7 +7301,7 @@ class Team:
                             audio=audio,
                             files=files,
                             stream=False,
-                            stream_intermediate_steps=stream_intermediate_steps,
+                            stream_events=stream_events,
                             debug_mode=debug_mode,
                             knowledge_filters=knowledge_filters
                             if not member_agent.knowledge_filters and member_agent.knowledge
@@ -7240,24 +7375,28 @@ class Team:
     ###########################################################################
     # Session Management
     ###########################################################################
-    def _read_session(self, session_id: str) -> Optional[TeamSession]:
+    def _read_session(
+        self, session_id: str, session_type: SessionType = SessionType.TEAM
+    ) -> Optional[Union[TeamSession, WorkflowSession]]:
         """Get a Session from the database."""
         try:
             if not self.db:
                 raise ValueError("Db not initialized")
-            session = self.db.get_session(session_id=session_id, session_type=SessionType.TEAM)
+            session = self.db.get_session(session_id=session_id, session_type=session_type)
             return session  # type: ignore
         except Exception as e:
             log_warning(f"Error getting session from db: {e}")
             return None
 
-    async def _aread_session(self, session_id: str) -> Optional[TeamSession]:
+    async def _aread_session(
+        self, session_id: str, session_type: SessionType = SessionType.TEAM
+    ) -> Optional[Union[TeamSession, WorkflowSession]]:
         """Get a Session from the database."""
         try:
             if not self.db:
                 raise ValueError("Db not initialized")
             self.db = cast(AsyncBaseDb, self.db)
-            session = await self.db.get_session(session_id=session_id, session_type=SessionType.TEAM)
+            session = await self.db.get_session(session_id=session_id, session_type=session_type)
             return session  # type: ignore
         except Exception as e:
             log_warning(f"Error getting session from db: {e}")
@@ -7358,12 +7497,17 @@ class Team:
         # Create new session if none found
         if team_session is None:
             log_debug(f"Creating new TeamSession: {session_id}")
+            session_data = {}
+            if self.session_state is not None:
+                from copy import deepcopy
+
+                session_data["session_state"] = deepcopy(self.session_state)
             team_session = TeamSession(
                 session_id=session_id,
                 team_id=self.id,
                 user_id=user_id,
                 team_data=self._get_team_data(),
-                session_data={},
+                session_data=session_data,
                 metadata=self.metadata,
                 created_at=int(time()),
             )
@@ -7439,7 +7583,48 @@ class Team:
 
         # Load and return the session from the database
         if self.db is not None:
-            team_session = cast(TeamSession, self._read_session(session_id=session_id_to_load))  # type: ignore
+            loaded_session = None
+            # We have a standalone team, so we are loading a TeamSession
+            if self.workflow_id is None:
+                loaded_session = cast(TeamSession, self._read_session(session_id=session_id_to_load))  # type: ignore
+            # We have a workflow team, so we are loading a WorkflowSession
+            else:
+                loaded_session = cast(WorkflowSession, self._read_session(session_id=session_id_to_load))  # type: ignore
+
+            # Cache the session if relevant
+            if loaded_session is not None and self.cache_session:
+                self._agent_session = loaded_session
+
+            return loaded_session
+
+        log_debug(f"TeamSession {session_id_to_load} not found in db")
+        return None
+
+    async def aget_session(
+        self,
+        session_id: Optional[str] = None,
+    ) -> Optional[TeamSession]:
+        """Load an TeamSession from database.
+
+        Args:
+            session_id: The session_id to load from storage.
+
+        Returns:
+            TeamSession: The TeamSession loaded from the database or created if it does not exist.
+        """
+        if not session_id and not self.session_id:
+            return None
+
+        session_id_to_load = session_id or self.session_id
+
+        # If there is a cached session, return it
+        if self.cache_session and hasattr(self, "_team_session") and self._team_session is not None:
+            if self._team_session.session_id == session_id_to_load:
+                return self._team_session
+
+        # Load and return the session from the database
+        if self.db is not None:
+            team_session = cast(TeamSession, await self._aread_session(session_id=session_id_to_load))  # type: ignore
 
             # Cache the session if relevant
             if team_session is not None and self.cache_session:
@@ -7478,7 +7663,17 @@ class Team:
                 session.session_data["session_state"].pop("current_session_id", None)  # type: ignore
                 session.session_data["session_state"].pop("current_user_id", None)  # type: ignore
                 session.session_data["session_state"].pop("current_run_id", None)  # type: ignore
-            await self._aupsert_session(session=session)
+
+            # scrub the member responses if not storing them
+            if not self.store_member_responses and session.runs is not None:
+                for run in session.runs:
+                    if hasattr(run, "member_responses"):
+                        run.member_responses = []
+
+            if self._has_async_db():
+                await self._aupsert_session(session=session)
+            else:
+                self._upsert_session(session=session)
             log_debug(f"Created or updated TeamSession record: {session.session_id}")
 
     def _load_session_state(self, session: TeamSession, session_state: Dict[str, Any]) -> Dict[str, Any]:
@@ -7608,6 +7803,60 @@ class Team:
             raise Exception("Session not found")
         return session.session_data.get("session_state", {}) if session.session_data is not None else {}
 
+    def update_session_state(self, session_state_updates: Dict[str, Any], session_id: Optional[str] = None) -> str:
+        """
+        Update the session state for the given session ID and user ID.
+        Args:
+            session_state_updates: The updates to apply to the session state. Should be a dictionary of key-value pairs.
+            session_id: The session ID to update. If not provided, the current cached session ID is used.
+        Returns:
+            dict: The updated session state.
+        """
+        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")
+
+        if session.session_data is not None and "session_state" not in session.session_data:
+            session.session_data["session_state"] = {}
+
+        for key, value in session_state_updates.items():
+            session.session_data["session_state"][key] = value  # type: ignore
+
+        self.save_session(session=session)
+
+        return session.session_data["session_state"]  # type: ignore
+
+    async def aupdate_session_state(
+        self, session_state_updates: Dict[str, Any], session_id: Optional[str] = None
+    ) -> str:
+        """
+        Update the session state for the given session ID and user ID.
+        Args:
+            session_state_updates: The updates to apply to the session state. Should be a dictionary of key-value pairs.
+            session_id: The session ID to update. If not provided, the current cached session ID is used.
+        Returns:
+            dict: The updated session state.
+        """
+        session_id = session_id or self.session_id
+        if session_id is None:
+            raise Exception("Session ID is not set")
+        session = await self.aget_session(session_id=session_id)  # type: ignore
+        if session is None:
+            raise Exception("Session not found")
+
+        if session.session_data is not None and "session_state" not in session.session_data:
+            session.session_data["session_state"] = {}
+
+        for key, value in session_state_updates.items():
+            session.session_data["session_state"][key] = value  # type: ignore
+
+        await self.asave_session(session=session)
+
+        return session.session_data["session_state"]  # type: ignore
+
     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
@@ -7708,7 +7957,9 @@ class Team:
             return ""
         team_member_interactions_str = ""
         if "member_responses" in team_run_context:
-            team_member_interactions_str += "<member interactions>\n"
+            team_member_interactions_str += (
+                "<member_interaction_context>\nSee below interactions wit other team members.\n"
+            )
 
             for interaction in team_run_context["member_responses"]:
                 response_dict = interaction["run_response"].to_dict()
@@ -7721,7 +7972,7 @@ class Team:
                 team_member_interactions_str += f"Task: {interaction['task']}\n"
                 team_member_interactions_str += f"Response: {response_content}\n"
                 team_member_interactions_str += "\n"
-            team_member_interactions_str += "</member interactions>\n"
+            team_member_interactions_str += "</member_interaction_context>\n"
         return team_member_interactions_str
 
     def _get_team_run_context_images(self, team_run_context: Dict[str, Any]) -> List[Image]:
@@ -7754,6 +8005,16 @@ class Team:
                     audio.extend(interaction["run_response"].audio)
         return audio
 
+    def _get_team_run_context_files(self, team_run_context: Dict[str, Any]) -> List[File]:
+        if not team_run_context:
+            return []
+        files = []
+        if "member_responses" in team_run_context:
+            for interaction in team_run_context["member_responses"]:
+                if interaction["run_response"].files:
+                    files.extend(interaction["run_response"].files)
+        return files
+
     ###########################################################################
     # Handle images, videos and audio
     ###########################################################################