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

agno/team/team.py

@@ -30,7 +30,7 @@ from uuid import uuid4
 from pydantic import BaseModel
 
 from agno.agent import Agent
-from agno.db.base import BaseDb, SessionType, UserMemory
+from agno.db.base import AsyncBaseDb, BaseDb, SessionType, UserMemory
 from agno.exceptions import (
     InputCheckError,
     ModelProviderError,
@@ -214,7 +214,7 @@ class Team:
 
     # --- Database ---
     # Database to use for this agent
-    db: Optional[BaseDb] = None
+    db: Optional[Union[BaseDb, AsyncBaseDb]] = None
 
     # Memory manager to use for this agent
     memory_manager: Optional[MemoryManager] = None
@@ -259,6 +259,10 @@ class Team:
     send_media_to_model: bool = True
     # If True, store media in run output
     store_media: bool = True
+    # If True, store tool results in run output
+    store_tool_messages: bool = True
+    # If True, store history messages in run output
+    store_history_messages: bool = True
 
     # --- Team Tools ---
     # A list of tools provided to the Model.
@@ -418,6 +422,8 @@ class Team:
         search_knowledge: bool = True,
         read_team_history: bool = False,
         store_media: bool = True,
+        store_tool_messages: bool = True,
+        store_history_messages: bool = True,
         send_media_to_model: bool = True,
         tools: Optional[List[Union[Toolkit, Callable, Function, Dict]]] = None,
         tool_call_limit: Optional[int] = None,
@@ -433,7 +439,7 @@ class Team:
         output_model_prompt: Optional[str] = None,
         use_json_mode: bool = False,
         parse_response: bool = True,
-        db: Optional[BaseDb] = None,
+        db: Optional[Union[BaseDb, AsyncBaseDb]] = None,
         enable_agentic_memory: bool = False,
         enable_user_memories: bool = False,
         add_memories_to_context: Optional[bool] = None,
@@ -518,6 +524,8 @@ class Team:
         self.read_team_history = read_team_history
 
         self.store_media = store_media
+        self.store_tool_messages = store_tool_messages
+        self.store_history_messages = store_history_messages
         self.send_media_to_model = send_media_to_model
 
         self.tools = tools
@@ -792,6 +800,10 @@ class Team:
 
         return session_id, user_id, session_state  # type: ignore
 
+    def _has_async_db(self) -> bool:
+        """Return True if the db the team is equipped with is an Async implementation"""
+        return self.db is not None and isinstance(self.db, AsyncBaseDb)
+
     def initialize_team(self, debug_mode: Optional[bool] = None) -> None:
         # Make sure for the team, we are using the team logger
         use_team_logger()
@@ -1205,7 +1217,11 @@ class Team:
         )
         deque(response_iterator, maxlen=0)
 
-        # 10. Save session to storage
+        # 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)
+
+        # 11. Save session to storage
         self.save_session(session=session)
 
         # Log Team Telemetry
@@ -1410,7 +1426,11 @@ class Team:
             # 8. Calculate session metrics
             self._update_session_metrics(session=session)
 
-            # 9. Save session to storage
+            # 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)
+
+            # 10. Save session to storage
             self.save_session(session=session)
 
             if stream_intermediate_steps:
@@ -1519,6 +1539,8 @@ class Team:
         **kwargs: Any,
     ) -> Union[TeamRunOutput, Iterator[Union[RunOutputEvent, TeamRunOutputEvent]]]:
         """Run the Team and return the response."""
+        if self._has_async_db():
+            raise Exception("run() is not supported with an async DB. Please use arun() instead.")
 
         # Create a run_id for this specific run
         run_id = str(uuid4())
@@ -1737,45 +1759,65 @@ class Team:
     async def _arun(
         self,
         run_response: TeamRunOutput,
-        session: TeamSession,
-        session_state: Dict[str, Any],
+        session_id: str,
+        session_state: Optional[Dict[str, Any]] = None,
         user_id: Optional[str] = None,
-        knowledge_filters: Optional[Dict[str, Any]] = None,
-        add_history_to_context: Optional[bool] = None,
+        response_format: Optional[Union[Dict, Type[BaseModel]]] = None,
         add_dependencies_to_context: Optional[bool] = None,
         add_session_state_to_context: Optional[bool] = None,
+        add_history_to_context: Optional[bool] = None,
+        knowledge_filters: Optional[Dict[str, Any]] = None,
         metadata: Optional[Dict[str, Any]] = None,
-        response_format: Optional[Union[Dict, Type[BaseModel]]] = None,
-        dependencies: 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,
     ) -> TeamRunOutput:
         """Run the Team and return the response.
 
         Steps:
-        1. Resolve dependencies
-        2. Execute pre-hooks
-        3. Prepare run messages
-        4. Reason about the task(s) if reasoning is enabled
-        5. Get a response from the model
-        6. Add RunOutput to Team Session
-        7. Calculate session metrics
-        8. Update Team Memory
-        9. Save session to storage
+        1. Read or create session
+        2. Update metadata and session state
+        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
         """
-        # 1. Resolve callable dependencies if present
-        if dependencies is not None:
-            await self._aresolve_run_dependencies(dependencies=dependencies)
+        log_debug(f"Team Run Start: {run_response.run_id}", center=True)
+
+        register_run(run_response.run_id)  # type: ignore
+
+        # 1. Read or create session. Reads from the database if provided.
+        if self._has_async_db():
+            team_session = await self._aread_or_create_session(session_id=session_id, user_id=user_id)
+        else:
+            team_session = self._read_or_create_session(session_id=session_id, user_id=user_id)
+
+        # 2. Update metadata and session state
+        self._update_metadata(session=team_session)
+        session_state = self._load_session_state(session=team_session, session_state=session_state)  # type: ignore
 
         run_input = cast(TeamRunInput, run_response.input)
-        self.model = cast(Model, self.model)
-        # 2. Execute pre-hooks after session is loaded but before processing starts
+
+        # 3. Execute pre-hooks after session is loaded but before processing starts
         if self.pre_hooks is not None:
             pre_hook_iterator = self._aexecute_pre_hooks(
                 hooks=self.pre_hooks,  # type: ignore
                 run_response=run_response,
                 run_input=run_input,
-                session=session,
+                session=team_session,
                 user_id=user_id,
                 debug_mode=debug_mode,
                 **kwargs,
@@ -1785,14 +1827,14 @@ class Team:
             async for _ in pre_hook_iterator:
                 pass
 
-        # Initialize the team run context
+        # 4. Determine tools for model
         team_run_context: Dict[str, Any] = {}
-
+        self.model = cast(Model, self.model)
         self.determine_tools_for_model(
             model=self.model,
             run_response=run_response,
             team_run_context=team_run_context,
-            session=session,
+            session=team_session,
             session_state=session_state,
             user_id=user_id,
             async_mode=True,
@@ -1810,39 +1852,36 @@ class Team:
             metadata=metadata,
         )
 
-        # 3. Prepare run messages
-        run_messages = self._get_run_messages(
+        # 5. Prepare run messages
+        run_messages = await self._aget_run_messages(
             run_response=run_response,
-            session=session,
+            session=team_session,  # type: ignore
             session_state=session_state,
             user_id=user_id,
             input_message=run_input.input_content,
-            audio=run_input.audios,
-            images=run_input.images,
-            videos=run_input.videos,
-            files=run_input.files,
+            audio=audio,
+            images=images,
+            videos=videos,
+            files=files,
             knowledge_filters=knowledge_filters,
             add_history_to_context=add_history_to_context,
             dependencies=dependencies,
             add_dependencies_to_context=add_dependencies_to_context,
             add_session_state_to_context=add_session_state_to_context,
-            metadata=metadata,
             **kwargs,
         )
 
-        self.model = cast(Model, self.model)
-        log_debug(f"Team Run Start: {run_response.run_id}", center=True)
-
         # Register run for cancellation tracking
         register_run(run_response.run_id)  # type: ignore
 
-        # 4. Reason about the task(s) if reasoning is enabled
+        # 6. Reason about the task(s) 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
 
-        # 5. Get the model response for the team leader
+        # 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,
@@ -1852,60 +1891,65 @@ class Team:
             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)
 
-        #  Update TeamRunOutput
+        # 8. Update TeamRunOutput
         self._update_run_response(model_response=model_response, run_response=run_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. Add the run to memory
+        team_session.upsert_run(run_response=run_response)
+
+        # 10. Calculate session metrics
+        self._update_session_metrics(session=team_session)
+
         run_response.status = RunStatus.completed
 
-        # Parse team response model
+        # 11. Parse team response model
         self._convert_response_to_structured_format(run_response=run_response)
 
         # Set the run duration
         if run_response.metrics:
             run_response.metrics.stop_timer()
 
-        # 6. Add the run to session
-        session.upsert_run(run_response=run_response)
-
-        # 6. Update Team Memory
+        # 12. Update Team Memory
         async for _ in self._amake_memories_and_summaries(
             run_response=run_response,
-            session=session,
+            session=team_session,
             run_messages=run_messages,
             user_id=user_id,
         ):
             pass
 
-        # 7. Calculate session metrics
-        self._update_session_metrics(session=session)
+        # 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)
 
-        # 8. Save session to storage
-        self.save_session(session=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=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)
 
-        # Execute post-hooks after output is generated but before response is returned
+        # 15. 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=session,
+                session=team_session,
                 user_id=user_id,
                 debug_mode=debug_mode,
                 **kwargs,
@@ -1913,7 +1957,6 @@ class Team:
 
         log_debug(f"Team Run End: {run_response.run_id}", center=True, symbol="*")
 
-        # Always clean up the run tracking
         cleanup_run(run_response.run_id)  # type: ignore
 
         return run_response
@@ -1921,40 +1964,60 @@ class Team:
     async def _arun_stream(
         self,
         run_response: TeamRunOutput,
-        session: TeamSession,
-        session_state: Dict[str, Any],
+        session_id: str,
+        session_state: Optional[Dict[str, Any]] = None,
         user_id: Optional[str] = None,
-        knowledge_filters: Optional[Dict[str, Any]] = None,
-        add_history_to_context: Optional[bool] = None,
-        add_dependencies_to_context: Optional[bool] = None,
-        add_session_state_to_context: Optional[bool] = None,
-        metadata: Optional[Dict[str, Any]] = None,
         response_format: Optional[Union[Dict, Type[BaseModel]]] = None,
-        dependencies: Optional[Dict[str, Any]] = None,
         stream_intermediate_steps: bool = False,
         yield_run_response: bool = False,
+        add_dependencies_to_context: Optional[bool] = None,
+        add_session_state_to_context: Optional[bool] = None,
+        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,
     ) -> AsyncIterator[Union[TeamRunOutputEvent, RunOutputEvent, TeamRunOutput]]:
         """Run the Team and return the response.
 
         Steps:
         1. Resolve dependencies
-        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. Read or create session
+        3. Update metadata and session state
+        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
+        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
         """
 
-        # 1. Resolve callable dependencies if present
+        # 1. Resolve dependencies
         if dependencies is not None:
-            await self._aresolve_run_dependencies(dependencies=dependencies)
+            self._resolve_run_dependencies(dependencies=dependencies)
+
+        # 2. Read or create session. Reads from the database if provided.
+        if self._has_async_db():
+            team_session = await self._aread_or_create_session(session_id=session_id, user_id=user_id)
+        else:
+            team_session = self._read_or_create_session(session_id=session_id, user_id=user_id)
+
+        # 3. Update metadata and session state
+        self._update_metadata(session=team_session)
+        session_state = self._load_session_state(session=team_session, session_state=session_state)  # type: ignore
 
-        # Execute pre-hooks
+        # 4. Execute pre-hooks
         run_input = cast(TeamRunInput, run_response.input)
         self.model = cast(Model, self.model)
         if self.pre_hooks is not None:
@@ -1962,7 +2025,7 @@ class Team:
                 hooks=self.pre_hooks,  # type: ignore
                 run_response=run_response,
                 run_input=run_input,
-                session=session,
+                session=team_session,
                 user_id=user_id,
                 debug_mode=debug_mode,
                 **kwargs,
@@ -1970,42 +2033,40 @@ class Team:
             async for pre_hook_event in pre_hook_iterator:
                 yield pre_hook_event
 
-        # Initialize the team run context
+        # 5. Determine tools for model
         team_run_context: Dict[str, Any] = {}
-
+        self.model = cast(Model, self.model)
         self.determine_tools_for_model(
             model=self.model,
             run_response=run_response,
             team_run_context=team_run_context,
-            session=session,
+            session=team_session,  # type: ignore
             session_state=session_state,
             user_id=user_id,
             async_mode=True,
             knowledge_filters=knowledge_filters,
             input_message=run_input.input_content,
-            images=run_input.images,
-            videos=run_input.videos,
-            audio=run_input.audios,
-            files=run_input.files,
+            images=images,
+            videos=videos,
+            audio=audio,
+            files=files,
             debug_mode=debug_mode,
             add_history_to_context=add_history_to_context,
-            add_dependencies_to_context=add_dependencies_to_context,
-            add_session_state_to_context=add_session_state_to_context,
             dependencies=dependencies,
             metadata=metadata,
         )
 
-        # 2. Prepare run messages
-        run_messages = self._get_run_messages(
+        # 6. Prepare run messages
+        run_messages = await self._aget_run_messages(
             run_response=run_response,
-            session=session,
+            session=team_session,  # type: ignore
             session_state=session_state,
             user_id=user_id,
             input_message=run_input.input_content,
-            audio=run_input.audios,
-            images=run_input.images,
-            videos=run_input.videos,
-            files=run_input.files,
+            audio=audio,
+            images=images,
+            videos=videos,
+            files=files,
             knowledge_filters=knowledge_filters,
             add_history_to_context=add_history_to_context,
             dependencies=dependencies,
@@ -2021,13 +2082,11 @@ class Team:
         register_run(run_response.run_id)  # type: ignore
 
         try:
-            # Start the Run by yielding a RunStarted event
+            # 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
-                )
+                yield self._handle_event(create_team_run_started_event(from_run_response=run_response), run_response)
 
-            # 3. Reason about the task(s) if reasoning is enabled
+            # 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):
                 raise_if_cancelled(run_response.run_id)  # type: ignore
                 yield item
@@ -2035,10 +2094,10 @@ class Team:
             # Check for cancellation before model processing
             raise_if_cancelled(run_response.run_id)  # type: ignore
 
-            # 4. Get a response from the model
+            # 9. Get a response from the model
             if self.output_model is None:
                 async for event in self._ahandle_model_response_stream(
-                    session=session,
+                    session=team_session,
                     run_response=run_response,
                     run_messages=run_messages,
                     response_format=response_format,
@@ -2048,7 +2107,7 @@ class Team:
                     yield event
             else:
                 async for event in self._ahandle_model_response_stream(
-                    session=session,
+                    session=team_session,
                     run_response=run_response,
                     run_messages=run_messages,
                     response_format=response_format,
@@ -2067,7 +2126,7 @@ class Team:
                         yield event
 
                 async for event in self._agenerate_response_with_output_model_stream(
-                    session=session,
+                    session=team_session,
                     run_response=run_response,
                     run_messages=run_messages,
                     stream_intermediate_steps=stream_intermediate_steps,
@@ -2080,38 +2139,41 @@ class Team:
 
             # If a parser model is provided, structure the response separately
             async for event in self._aparse_response_with_parser_model_stream(
-                session=session, run_response=run_response, stream_intermediate_steps=stream_intermediate_steps
+                session=team_session, run_response=run_response, stream_intermediate_steps=stream_intermediate_steps
             ):
                 yield event
 
             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)
+            # 10. Add the run to memory
+            team_session.upsert_run(run_response=run_response)
 
-            # 6. Update Team Memory
+            # 11. Update Team Memory
             async for event in self._amake_memories_and_summaries(
                 run_response=run_response,
-                session=session,
+                session=team_session,
                 run_messages=run_messages,
                 user_id=user_id,
             ):
                 yield event
 
-            # 7. Create the run completed event
+            # 12. Calculate session metrics
+            self._update_session_metrics(session=team_session)
+
+            # 13. Create the run completed event
             completed_event = self._handle_event(
                 create_team_run_completed_event(from_run_response=run_response), run_response
             )
 
-            # 8. Calculate session metrics
-            self._update_session_metrics(session=session)
+            # 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)
 
-            # 9. Save session to storage
-            self.save_session(session=session)
+            # 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)
 
             if stream_intermediate_steps:
                 yield completed_event
@@ -2120,7 +2182,7 @@ class Team:
                 yield run_response
 
             # Log Team Telemetry
-            await self._alog_team_telemetry(session_id=session.session_id, run_id=run_response.run_id)
+            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="*")
 
@@ -2137,8 +2199,11 @@ class Team:
             )
 
             # Add the RunOutput to Team Session even when cancelled
-            session.upsert_run(run_response=run_response)
-            self.save_session(session=session)
+            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)
         finally:
             # Always clean up the run tracking
             cleanup_run(run_response.run_id)  # type: ignore
@@ -2245,25 +2310,8 @@ class Team:
             images=images, videos=videos, audios=audio, files=files
         )
 
-        # Create RunInput to capture the original user input
-        run_input = TeamRunInput(
-            input_content=validated_input,
-            images=image_artifacts,
-            videos=video_artifacts,
-            audios=audio_artifacts,
-            files=file_artifacts,
-        )
-
-        team_session = self._read_or_create_session(session_id=session_id, user_id=user_id)
-        self._update_metadata(session=team_session)
-
-        # Update session state from DB
-        session_state = self._load_session_state(session=team_session, session_state=session_state)
-
-        # Determine run dependencies (runtime override takes priority)
+        # Resolve variables
         run_dependencies = dependencies if dependencies is not None else self.dependencies
-
-        # Determine runtime context parameters
         add_dependencies = (
             add_dependencies_to_context if add_dependencies_to_context is not None else self.add_dependencies_to_context
         )
@@ -2274,10 +2322,14 @@ class Team:
         )
         add_history = add_history_to_context if add_history_to_context is not None else self.add_history_to_context
 
-        effective_filters = knowledge_filters
-        # When filters are passed manually
-        if self.knowledge_filters or knowledge_filters:
-            effective_filters = self._get_effective_filters(knowledge_filters)
+        # Create RunInput to capture the original user input
+        run_input = TeamRunInput(
+            input_content=validated_input,
+            images=image_artifacts,
+            videos=video_artifacts,
+            audios=audio_artifacts,
+            files=files,
+        )
 
         # Use stream override value when necessary
         if stream is None:
@@ -2308,6 +2360,11 @@ class Team:
             else:
                 metadata = self.metadata
 
+        #  Get knowledge filters
+        effective_filters = knowledge_filters
+        if self.knowledge_filters or knowledge_filters:
+            effective_filters = self._get_effective_filters(knowledge_filters)
+
         # Create a new run_response for this attempt
         run_response = TeamRunOutput(
             run_id=run_id,
@@ -2337,8 +2394,9 @@ class Team:
             try:
                 if stream:
                     response_iterator = self._arun_stream(
+                        input=validated_input,
                         run_response=run_response,
-                        session=team_session,  # type: ignore
+                        session_id=session_id,
                         session_state=session_state,
                         user_id=user_id,
                         knowledge_filters=effective_filters,
@@ -2356,18 +2414,23 @@ class Team:
                     return response_iterator  # type: ignore
                 else:
                     return self._arun(  # type: ignore
+                        input=validated_input,
                         run_response=run_response,
-                        session=team_session,  # type: ignore
-                        user_id=user_id,
+                        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,
                         add_session_state_to_context=add_session_state,
                         metadata=metadata,
                         response_format=response_format,
-                        dependencies=run_dependencies,
                         debug_mode=debug_mode,
+                        dependencies=run_dependencies,
                         **kwargs,
                     )
 
@@ -2385,17 +2448,6 @@ class Team:
                     import time
 
                     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
@@ -3025,7 +3077,9 @@ class Team:
             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))
+            tasks.append(
+                self.memory_manager.acreate_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))
@@ -3395,6 +3449,11 @@ class Team:
         tags_to_include_in_markdown: Optional[Set[str]] = None,
         **kwargs: Any,
     ) -> None:
+        if self._has_async_db():
+            raise Exception(
+                "This method is not supported with an async DB. Please use the async version of this method."
+            )
+
         if not tags_to_include_in_markdown:
             tags_to_include_in_markdown = {"think", "thinking"}
 
@@ -3583,8 +3642,6 @@ class Team:
             run_response.input.audios = []
             run_response.input.files = []
 
-        # 2. RunOutput artifact media are skipped since we don't store them when store_media=False
-
         # 3. Scrub media from all messages
         if run_response.messages:
             for message in run_response.messages:
@@ -3613,6 +3670,100 @@ class Team:
         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.
+        Returns True if any scrubbing was done, False otherwise.
+        """
+        scrubbed = False
+
+        if not self.store_media:
+            self._scrub_media_from_run_output(run_response)
+            scrubbed = True
+
+        if not self.store_tool_messages:
+            self._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)
+            scrubbed = True
+
+        return scrubbed
+
+    def _scrub_member_responses(self, member_responses: List[Union[TeamRunOutput, RunOutput]]) -> None:
+        """
+        Scrub member responses based on each member's storage flags.
+        This is called when saving the team session to ensure member data is scrubbed per member settings.
+        Recursively handles nested team's member responses.
+        """
+        for member_response in member_responses:
+            member_id = None
+            if isinstance(member_response, RunOutput):
+                member_id = member_response.agent_id
+            elif isinstance(member_response, TeamRunOutput):
+                member_id = member_response.team_id
+
+            if not member_id:
+                log_info("Skipping member response with no ID")
+                continue
+
+            member_result = self._find_member_by_id(member_id)
+            if not member_result:
+                log_debug(f"Could not find member with ID: {member_id}")
+                continue
+
+            _, member = member_result
+
+            if not member.store_media or not member.store_tool_messages or not member.store_history_messages:
+                member._scrub_run_output_for_storage(member_response)  # type: ignore
+            
+            # If this is a nested team, recursively scrub its member responses
+            if isinstance(member_response, TeamRunOutput) and member_response.member_responses:
+                member._scrub_member_responses(member_response.member_responses)  # type: ignore
+
     def _validate_media_object_id(
         self,
         images: Optional[Sequence[Image]] = None,
@@ -3856,12 +4007,15 @@ class Team:
 
         # If a reasoning model is provided, use it to generate reasoning
         if reasoning_model_provided:
+            from agno.reasoning.anthropic import is_anthropic_reasoning_model
             from agno.reasoning.azure_ai_foundry import is_ai_foundry_reasoning_model
             from agno.reasoning.deepseek import is_deepseek_reasoning_model
+            from agno.reasoning.gemini import is_gemini_reasoning_model
             from agno.reasoning.groq import is_groq_reasoning_model
             from agno.reasoning.helpers import get_reasoning_agent
             from agno.reasoning.ollama import is_ollama_reasoning_model
             from agno.reasoning.openai import is_openai_reasoning_model
+            from agno.reasoning.vertexai import is_vertexai_reasoning_model
 
             reasoning_agent = self.reasoning_agent or get_reasoning_agent(
                 reasoning_model=reasoning_model,
@@ -3874,8 +4028,20 @@ class Team:
             is_openai = is_openai_reasoning_model(reasoning_model)
             is_ollama = is_ollama_reasoning_model(reasoning_model)
             is_ai_foundry = is_ai_foundry_reasoning_model(reasoning_model)
+            is_gemini = is_gemini_reasoning_model(reasoning_model)
+            is_anthropic = is_anthropic_reasoning_model(reasoning_model)
+            is_vertexai = is_vertexai_reasoning_model(reasoning_model)
 
-            if is_deepseek or is_groq or is_openai or is_ollama or is_ai_foundry:
+            if (
+                is_deepseek
+                or is_groq
+                or is_openai
+                or is_ollama
+                or is_ai_foundry
+                or is_gemini
+                or is_anthropic
+                or is_vertexai
+            ):
                 reasoning_message: Optional[Message] = None
                 if is_deepseek:
                     from agno.reasoning.deepseek import get_deepseek_reasoning
@@ -3912,6 +4078,27 @@ class Team:
                     reasoning_message = get_ai_foundry_reasoning(
                         reasoning_agent=reasoning_agent, messages=run_messages.get_input_messages()
                     )
+                elif is_gemini:
+                    from agno.reasoning.gemini import get_gemini_reasoning
+
+                    log_debug("Starting Gemini Reasoning", center=True, symbol="=")
+                    reasoning_message = get_gemini_reasoning(
+                        reasoning_agent=reasoning_agent, messages=run_messages.get_input_messages()
+                    )
+                elif is_anthropic:
+                    from agno.reasoning.anthropic import get_anthropic_reasoning
+
+                    log_debug("Starting Anthropic Claude Reasoning", center=True, symbol="=")
+                    reasoning_message = get_anthropic_reasoning(
+                        reasoning_agent=reasoning_agent, messages=run_messages.get_input_messages()
+                    )
+                elif is_vertexai:
+                    from agno.reasoning.vertexai import get_vertexai_reasoning
+
+                    log_debug("Starting VertexAI Reasoning", center=True, symbol="=")
+                    reasoning_message = get_vertexai_reasoning(
+                        reasoning_agent=reasoning_agent, messages=run_messages.get_input_messages()
+                    )
 
                 if reasoning_message is None:
                     log_warning("Reasoning error. Reasoning response is None, continuing regular session...")
@@ -4090,12 +4277,15 @@ class Team:
 
         # If a reasoning model is provided, use it to generate reasoning
         if reasoning_model_provided:
+            from agno.reasoning.anthropic import is_anthropic_reasoning_model
             from agno.reasoning.azure_ai_foundry import is_ai_foundry_reasoning_model
             from agno.reasoning.deepseek import is_deepseek_reasoning_model
+            from agno.reasoning.gemini import is_gemini_reasoning_model
             from agno.reasoning.groq import is_groq_reasoning_model
             from agno.reasoning.helpers import get_reasoning_agent
             from agno.reasoning.ollama import is_ollama_reasoning_model
             from agno.reasoning.openai import is_openai_reasoning_model
+            from agno.reasoning.vertexai import is_vertexai_reasoning_model
 
             reasoning_agent = self.reasoning_agent or get_reasoning_agent(
                 reasoning_model=reasoning_model,
@@ -4108,8 +4298,20 @@ class Team:
             is_openai = is_openai_reasoning_model(reasoning_model)
             is_ollama = is_ollama_reasoning_model(reasoning_model)
             is_ai_foundry = is_ai_foundry_reasoning_model(reasoning_model)
+            is_gemini = is_gemini_reasoning_model(reasoning_model)
+            is_anthropic = is_anthropic_reasoning_model(reasoning_model)
+            is_vertexai = is_vertexai_reasoning_model(reasoning_model)
 
-            if is_deepseek or is_groq or is_openai or is_ollama or is_ai_foundry:
+            if (
+                is_deepseek
+                or is_groq
+                or is_openai
+                or is_ollama
+                or is_ai_foundry
+                or is_gemini
+                or is_anthropic
+                or is_vertexai
+            ):
                 reasoning_message: Optional[Message] = None
                 if is_deepseek:
                     from agno.reasoning.deepseek import aget_deepseek_reasoning
@@ -4146,6 +4348,27 @@ class Team:
                     reasoning_message = get_ai_foundry_reasoning(
                         reasoning_agent=reasoning_agent, messages=run_messages.get_input_messages()
                     )
+                elif is_gemini:
+                    from agno.reasoning.gemini import aget_gemini_reasoning
+
+                    log_debug("Starting Gemini Reasoning", center=True, symbol="=")
+                    reasoning_message = await aget_gemini_reasoning(
+                        reasoning_agent=reasoning_agent, messages=run_messages.get_input_messages()
+                    )
+                elif is_anthropic:
+                    from agno.reasoning.anthropic import aget_anthropic_reasoning
+
+                    log_debug("Starting Anthropic Claude Reasoning", center=True, symbol="=")
+                    reasoning_message = await aget_anthropic_reasoning(
+                        reasoning_agent=reasoning_agent, messages=run_messages.get_input_messages()
+                    )
+                elif is_vertexai:
+                    from agno.reasoning.vertexai import aget_vertexai_reasoning
+
+                    log_debug("Starting VertexAI Reasoning", center=True, symbol="=")
+                    reasoning_message = await aget_vertexai_reasoning(
+                        reasoning_agent=reasoning_agent, messages=run_messages.get_input_messages()
+                    )
 
                 if reasoning_message is None:
                     log_warning("Reasoning error. Reasoning response is None, continuing regular session...")
@@ -4715,7 +4938,7 @@ class Team:
                     system_message_content += f"{indent * ' '}   - Name: {member.name}\n"
                 if member.role is not None:
                     system_message_content += f"{indent * ' '}   - Role: {member.role}\n"
-                if member.tools and self.add_member_tools_to_context:
+                if member.tools is not None and member.tools != [] and self.add_member_tools_to_context:
                     system_message_content += f"{indent * ' '}   - Member tools:\n"
                     for _tool in member.tools:
                         if isinstance(_tool, Toolkit):
@@ -4921,9 +5144,7 @@ class Team:
                 _memory_manager_not_set = True
             user_memories = self.memory_manager.get_user_memories(user_id=user_id)  # type: ignore
             if user_memories and len(user_memories) > 0:
-                system_message_content += (
-                    "You have access to memories from previous interactions with the user that you can use:\n\n"
-                )
+                system_message_content += "You have access to user info and preferences from previous interactions that you can use to personalize your response:\n\n"
                 system_message_content += "<memories_from_previous_interactions>"
                 for _memory in user_memories:  # type: ignore
                     system_message_content += f"\n- {_memory.memory}"
@@ -5025,6 +5246,305 @@ class Team:
 
         return Message(role=self.system_message_role, content=system_message_content.strip())
 
+    async def aget_system_message(
+        self,
+        session: TeamSession,
+        session_state: Optional[Dict[str, Any]] = None,
+        user_id: Optional[str] = None,
+        audio: Optional[Sequence[Audio]] = None,
+        images: Optional[Sequence[Image]] = None,
+        videos: Optional[Sequence[Video]] = None,
+        files: Optional[Sequence[File]] = None,
+        dependencies: Optional[Dict[str, Any]] = None,
+        metadata: Optional[Dict[str, Any]] = None,
+        add_session_state_to_context: Optional[bool] = None,
+    ) -> Optional[Message]:
+        """Get the system message for the team."""
+
+        # 1. If the system_message is provided, use that.
+        if self.system_message is not None:
+            if isinstance(self.system_message, Message):
+                return self.system_message
+
+            sys_message_content: str = ""
+            if isinstance(self.system_message, str):
+                sys_message_content = self.system_message
+            elif callable(self.system_message):
+                sys_message_content = self.system_message(agent=self)
+                if not isinstance(sys_message_content, str):
+                    raise Exception("system_message must return a string")
+
+            # Format the system message with the session state variables
+            if self.resolve_in_context:
+                sys_message_content = self._format_message_with_state_variables(
+                    sys_message_content,
+                    user_id=user_id,
+                    session_state=session_state,
+                    dependencies=dependencies,
+                    metadata=metadata,
+                )
+
+            # type: ignore
+            return Message(role=self.system_message_role, content=sys_message_content)
+
+        # 1. Build and return the default system message for the Team.
+        # 1.1 Build the list of instructions for the system message
+        self.model = cast(Model, self.model)
+        instructions: List[str] = []
+        if self.instructions is not None:
+            _instructions = self.instructions
+            if callable(self.instructions):
+                import inspect
+
+                signature = inspect.signature(self.instructions)
+                if "team" in signature.parameters:
+                    _instructions = self.instructions(team=self)
+                elif "agent" in signature.parameters:
+                    _instructions = self.instructions(agent=self)
+                else:
+                    _instructions = self.instructions()
+
+            if isinstance(_instructions, str):
+                instructions.append(_instructions)
+            elif isinstance(_instructions, list):
+                instructions.extend(_instructions)
+
+        # 1.2 Add instructions from the Model
+        _model_instructions = self.model.get_instructions_for_model(self._tools_for_model)
+        if _model_instructions is not None:
+            instructions.extend(_model_instructions)
+
+        # 1.3 Build a list of additional information for the system message
+        additional_information: List[str] = []
+        # 1.3.1 Add instructions for using markdown
+        if self.markdown and self.output_schema is None:
+            additional_information.append("Use markdown to format your answers.")
+        # 1.3.2 Add the current datetime
+        if self.add_datetime_to_context:
+            from datetime import datetime
+
+            tz = None
+
+            if self.timezone_identifier:
+                try:
+                    from zoneinfo import ZoneInfo
+
+                    tz = ZoneInfo(self.timezone_identifier)
+                except Exception:
+                    log_warning("Invalid timezone identifier")
+
+            time = datetime.now(tz) if tz else datetime.now()
+
+            additional_information.append(f"The current time is {time}.")
+
+        # 1.3.3 Add the current location
+        if self.add_location_to_context:
+            from agno.utils.location import get_location
+
+            location = get_location()
+            if location:
+                location_str = ", ".join(
+                    filter(None, [location.get("city"), location.get("region"), location.get("country")])
+                )
+                if location_str:
+                    additional_information.append(f"Your approximate location is: {location_str}.")
+
+        # 1.3.4 Add team name if provided
+        if self.name is not None and self.add_name_to_context:
+            additional_information.append(f"Your name is: {self.name}.")
+
+        if self.knowledge is not None and self.enable_agentic_knowledge_filters:
+            valid_filters = getattr(self.knowledge, "valid_metadata_filters", None)
+            if valid_filters:
+                valid_filters_str = ", ".join(valid_filters)
+                additional_information.append(
+                    dedent(f"""
+                    The knowledge base contains documents with these metadata filters: {valid_filters_str}.
+                    Always use filters when the user query indicates specific metadata.
+                    Examples:
+                    1. If the user asks about a specific person like "Jordan Mitchell", you MUST use the search_knowledge_base tool with the filters parameter set to {{'<valid key like user_id>': '<valid value based on the user query>'}}.
+                    2. If the user asks about a specific document type like "contracts", you MUST use the search_knowledge_base tool with the filters parameter set to {{'document_type': 'contract'}}.
+                    4. If the user asks about a specific location like "documents from New York", you MUST use the search_knowledge_base tool with the filters parameter set to {{'<valid key like location>': 'New York'}}.
+                    General Guidelines:
+                    - Always analyze the user query to identify relevant metadata.
+                    - Use the most specific filter(s) possible to narrow down results.
+                    - If multiple filters are relevant, combine them in the filters parameter (e.g., {{'name': 'Jordan Mitchell', 'document_type': 'contract'}}).
+                    - Ensure the filter keys match the valid metadata filters: {valid_filters_str}.
+                    You can use the search_knowledge_base tool to search the knowledge base and get the most relevant documents. Make sure to pass the filters as [Dict[str: Any]] to the tool. FOLLOW THIS STRUCTURE STRICTLY.
+                """)
+                )
+
+        # 2 Build the default system message for the Agent.
+        system_message_content: str = ""
+        system_message_content += "You are the leader of a team and sub-teams of AI Agents.\n"
+        system_message_content += "Your task is to coordinate the team to complete the user's request.\n"
+
+        system_message_content += "\nHere are the members in your team:\n"
+        system_message_content += "<team_members>\n"
+        system_message_content += self.get_members_system_message_content()
+        if self.get_member_information_tool:
+            system_message_content += "If you need to get information about your team members, you can use the `get_member_information` tool at any time.\n"
+        system_message_content += "</team_members>\n"
+
+        system_message_content += "\n<how_to_respond>\n"
+
+        if self.delegate_task_to_all_members:
+            system_message_content += (
+                "- Your role is to forward tasks to members in your team with the highest likelihood of completing the user's request.\n"
+                "- You can either respond directly or use the `delegate_task_to_members` tool to delegate a task to all members in your team to get a collaborative response.\n"
+                "- To delegate a task to all members in your team, call `delegate_task_to_members` ONLY once. This will delegate a task to all members in your team.\n"
+                "- Analyze the responses from all members and evaluate whether the task has been completed.\n"
+                "- If you feel the task has been completed, you can stop and respond to the user.\n"
+            )
+        else:
+            system_message_content += (
+                "- Your role is to delegate tasks to members in your team with the highest likelihood of completing the user's request.\n"
+                "- Carefully analyze the tools available to the members and their roles before delegating tasks.\n"
+                "- 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"
+                "- 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"
+                "- 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"
+            )
+        system_message_content += "</how_to_respond>\n\n"
+
+        # Attached media
+        if audio is not None or images is not None or videos is not None or files is not None:
+            system_message_content += "<attached_media>\n"
+            system_message_content += "You have the following media attached to your message:\n"
+            if audio is not None and len(audio) > 0:
+                system_message_content += " - Audio\n"
+            if images is not None and len(images) > 0:
+                system_message_content += " - Images\n"
+            if videos is not None and len(videos) > 0:
+                system_message_content += " - Videos\n"
+            if files is not None and len(files) > 0:
+                system_message_content += " - Files\n"
+            system_message_content += "</attached_media>\n\n"
+
+        # Then add memories to the system prompt
+        if self.add_memories_to_context:
+            _memory_manager_not_set = False
+            if not user_id:
+                user_id = "default"
+            if self.memory_manager is None:
+                self._set_memory_manager()
+                _memory_manager_not_set = True
+
+            if self._has_async_db():
+                user_memories = await self.memory_manager.aget_user_memories(user_id=user_id)  # type: ignore
+            else:
+                user_memories = self.memory_manager.get_user_memories(user_id=user_id)  # type: ignore
+
+            if user_memories and len(user_memories) > 0:
+                system_message_content += "You have access to user info and preferences from previous interactions that you can use to personalize your response:\n\n"
+                system_message_content += "<memories_from_previous_interactions>"
+                for _memory in user_memories:  # type: ignore
+                    system_message_content += f"\n- {_memory.memory}"
+                system_message_content += "\n</memories_from_previous_interactions>\n\n"
+                system_message_content += (
+                    "Note: this information is from previous interactions and may be updated in this conversation. "
+                    "You should always prefer information from this conversation over the past memories.\n"
+                )
+            else:
+                system_message_content += (
+                    "You have the capability to retain memories from previous interactions with the user, "
+                    "but have not had any interactions with the user yet.\n"
+                )
+            if _memory_manager_not_set:
+                self.memory_manager = None
+
+            if self.enable_agentic_memory:
+                system_message_content += (
+                    "\n<updating_user_memories>\n"
+                    "- You have access to the `update_user_memory` tool that you can use to add new memories, update existing memories, delete memories, or clear all memories.\n"
+                    "- If the user's message includes information that should be captured as a memory, use the `update_user_memory` tool to update your memory database.\n"
+                    "- Memories should include details that could personalize ongoing interactions with the user.\n"
+                    "- Use this tool to add new memories or update existing memories that you identify in the conversation.\n"
+                    "- Use this tool if the user asks to update their memory, delete a memory, or clear all memories.\n"
+                    "- If you use the `update_user_memory` tool, remember to pass on the response to the user.\n"
+                    "</updating_user_memories>\n\n"
+                )
+
+        # Then add a summary of the interaction to the system prompt
+        if self.add_session_summary_to_context and session.summary is not None:
+            system_message_content += "Here is a brief summary of your previous interactions:\n\n"
+            system_message_content += "<summary_of_previous_interactions>\n"
+            system_message_content += session.summary.summary
+            system_message_content += "\n</summary_of_previous_interactions>\n\n"
+            system_message_content += (
+                "Note: this information is from previous interactions and may be outdated. "
+                "You should ALWAYS prefer information from this conversation over the past summary.\n\n"
+            )
+
+        if self.description is not None:
+            system_message_content += f"<description>\n{self.description}\n</description>\n\n"
+
+        if self.role is not None:
+            system_message_content += f"\n<your_role>\n{self.role}\n</your_role>\n\n"
+
+        # 3.3.5 Then add instructions for the Agent
+        if len(instructions) > 0:
+            system_message_content += "<instructions>"
+            if len(instructions) > 1:
+                for _upi in instructions:
+                    system_message_content += f"\n- {_upi}"
+            else:
+                system_message_content += "\n" + instructions[0]
+            system_message_content += "\n</instructions>\n\n"
+        # 3.3.6 Add additional information
+        if len(additional_information) > 0:
+            system_message_content += "<additional_information>"
+            for _ai in additional_information:
+                system_message_content += f"\n- {_ai}"
+            system_message_content += "\n</additional_information>\n\n"
+        # 3.3.7 Then add instructions for the tools
+        if self._tool_instructions is not None:
+            for _ti in self._tool_instructions:
+                system_message_content += f"{_ti}\n"
+
+        # Format the system message with the session state variables
+        if self.resolve_in_context:
+            system_message_content = self._format_message_with_state_variables(
+                system_message_content,
+                user_id=user_id,
+                session_state=session_state,
+                dependencies=dependencies,
+                metadata=metadata,
+            )
+
+        system_message_from_model = self.model.get_system_message_for_model(self._tools_for_model)
+        if system_message_from_model is not None:
+            system_message_content += system_message_from_model
+
+        if self.expected_output is not None:
+            system_message_content += f"<expected_output>\n{self.expected_output.strip()}\n</expected_output>\n\n"
+
+        if self.additional_context is not None:
+            system_message_content += (
+                f"<additional_context>\n{self.additional_context.strip()}\n</additional_context>\n\n"
+            )
+
+        if self.add_session_state_to_context:
+            system_message_content += f"<session_state>\n{session_state}\n</session_state>\n\n"
+
+        # Add the JSON output prompt if output_schema is provided and structured_outputs is False
+        if (
+            self.output_schema is not None
+            and self.use_json_mode
+            and self.model
+            and self.model.supports_native_structured_outputs
+        ):
+            system_message_content += f"{self._get_json_output_prompt()}"
+
+        return Message(role=self.system_message_role, content=system_message_content.strip())
+
     def _get_formatted_session_state_for_system_message(self, session_state: Dict[str, Any]) -> str:
         return f"\n<session_state>\n{session_state}\n</session_state>\n\n"
 
@@ -5163,6 +5683,134 @@ class Team:
 
         return run_messages
 
+    async def _aget_run_messages(
+        self,
+        *,
+        run_response: TeamRunOutput,
+        session: TeamSession,
+        session_state: Optional[Dict[str, Any]] = None,
+        user_id: Optional[str] = None,
+        input_message: Optional[Union[str, List, Dict, Message, BaseModel, List[Message]]] = None,
+        audio: Optional[Sequence[Audio]] = None,
+        images: Optional[Sequence[Image]] = None,
+        videos: Optional[Sequence[Video]] = None,
+        files: Optional[Sequence[File]] = None,
+        knowledge_filters: Optional[Dict[str, Any]] = None,
+        add_history_to_context: Optional[bool] = None,
+        dependencies: Optional[Dict[str, Any]] = None,
+        add_dependencies_to_context: Optional[bool] = None,
+        add_session_state_to_context: Optional[bool] = None,
+        metadata: Optional[Dict[str, Any]] = None,
+        **kwargs: Any,
+    ) -> RunMessages:
+        """This function returns a RunMessages object with the following attributes:
+            - system_message: The system message for this run
+            - user_message: The user message for this run
+            - messages: List of messages to send to the model
+
+        To build the RunMessages object:
+        1. Add system message to run_messages
+        2. Add extra messages to run_messages
+        3. Add history to run_messages
+        4. Add messages to run_messages if provided (messages parameter first)
+        5. Add user message to run_messages (message parameter second)
+
+        """
+        # Initialize the RunMessages object
+        run_messages = RunMessages()
+
+        # 1. Add system message to run_messages
+        system_message = await self.aget_system_message(
+            session=session,
+            session_state=session_state,
+            user_id=user_id,
+            images=images,
+            audio=audio,
+            videos=videos,
+            files=files,
+            dependencies=dependencies,
+            metadata=metadata,
+            add_session_state_to_context=add_session_state_to_context,
+        )
+        if system_message is not None:
+            run_messages.system_message = system_message
+            run_messages.messages.append(system_message)
+
+        # 2. Add extra messages to run_messages if provided
+        if self.additional_input is not None:
+            messages_to_add_to_run_response: List[Message] = []
+            if run_messages.extra_messages is None:
+                run_messages.extra_messages = []
+
+            for _m in self.additional_input:
+                if isinstance(_m, Message):
+                    messages_to_add_to_run_response.append(_m)
+                    run_messages.messages.append(_m)
+                    run_messages.extra_messages.append(_m)
+                elif isinstance(_m, dict):
+                    try:
+                        _m_parsed = Message.model_validate(_m)
+                        messages_to_add_to_run_response.append(_m_parsed)
+                        run_messages.messages.append(_m_parsed)
+                        run_messages.extra_messages.append(_m_parsed)
+                    except Exception as e:
+                        log_warning(f"Failed to validate message: {e}")
+            # Add the extra messages to the run_response
+            if len(messages_to_add_to_run_response) > 0:
+                log_debug(f"Adding {len(messages_to_add_to_run_response)} extra messages")
+                if run_response.additional_input is None:
+                    run_response.additional_input = messages_to_add_to_run_response
+                else:
+                    run_response.additional_input.extend(messages_to_add_to_run_response)
+
+        # 3. Add history to run_messages
+        if add_history_to_context:
+            from copy import deepcopy
+
+            history = session.get_messages_from_last_n_runs(
+                last_n=self.num_history_runs,
+                skip_role=self.system_message_role,
+                team_id=self.id,
+            )
+
+            if len(history) > 0:
+                # Create a deep copy of the history messages to avoid modifying the original messages
+                history_copy = [deepcopy(msg) for msg in history]
+
+                # Tag each message as coming from history
+                for _msg in history_copy:
+                    _msg.from_history = True
+
+                log_debug(f"Adding {len(history_copy)} messages from history")
+
+                # Extend the messages with the history
+                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,
+            session_state=session_state,
+            input_message=input_message,
+            user_id=user_id,
+            audio=audio,
+            images=images,
+            videos=videos,
+            files=files,
+            knowledge_filters=knowledge_filters,
+            dependencies=dependencies,
+            add_dependencies_to_context=add_dependencies_to_context,
+            metadata=metadata,
+            **kwargs,
+        )
+        # Add user message to run_messages
+        if user_message is not None:
+            run_messages.user_message = user_message
+            run_messages.messages.append(user_message)
+
+        return run_messages
+
     def _get_user_message(
         self,
         *,
@@ -5662,6 +6310,7 @@ class Team:
             if self.db is None:
                 return "Previous session messages not available"
 
+            self.db = cast(BaseDb, self.db)
             selected_sessions = self.db.get_sessions(
                 session_type=SessionType.TEAM,
                 limit=num_history_sessions,
@@ -5701,7 +6350,62 @@ class Team:
 
             return json.dumps([msg.to_dict() for msg in all_messages]) if all_messages else "No history found"
 
-        return get_previous_session_messages
+        async def aget_previous_session_messages() -> str:
+            """Use this function to retrieve messages from previous chat sessions.
+            USE THIS TOOL ONLY WHEN THE QUESTION IS EITHER "What was my last conversation?" or "What was my last question?" and similar to it.
+
+            Returns:
+                str: JSON formatted list of message pairs from previous sessions
+            """
+            import json
+
+            if self.db is None:
+                return "Previous session messages not available"
+
+            self.db = cast(AsyncBaseDb, self.db)
+            selected_sessions = await self.db.get_sessions(
+                session_type=SessionType.TEAM,
+                limit=num_history_sessions,
+                user_id=user_id,
+                sort_by="created_at",
+                sort_order="desc",
+            )
+
+            all_messages = []
+            seen_message_pairs = set()
+
+            for session in selected_sessions:
+                if isinstance(session, TeamSession) and session.runs:
+                    message_count = 0
+                    for run in session.runs:
+                        messages = run.messages
+                        if messages is not None:
+                            for i in range(0, len(messages) - 1, 2):
+                                if i + 1 < len(messages):
+                                    try:
+                                        user_msg = messages[i]
+                                        assistant_msg = messages[i + 1]
+                                        user_content = user_msg.content
+                                        assistant_content = assistant_msg.content
+                                        if user_content is None or assistant_content is None:
+                                            continue  # Skip this pair if either message has no content
+
+                                        msg_pair_id = f"{user_content}:{assistant_content}"
+                                        if msg_pair_id not in seen_message_pairs:
+                                            seen_message_pairs.add(msg_pair_id)
+                                            all_messages.append(Message.model_validate(user_msg))
+                                            all_messages.append(Message.model_validate(assistant_msg))
+                                            message_count += 1
+                                    except Exception as e:
+                                        log_warning(f"Error processing message pair: {e}")
+                                        continue
+
+            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
+        else:
+            return get_previous_session_messages
 
     def _get_history_for_member_agent(self, session: TeamSession, member_agent: Union[Agent, "Team"]) -> List[Message]:
         from copy import deepcopy
@@ -5894,8 +6598,16 @@ class Team:
             if run_response and member_agent_run_response:
                 run_response.add_member_run(member_agent_run_response)
 
-            # Add the member run to the team session
+            # Scrub the member run based on that member's storage flags before storing
             if member_agent_run_response:
+                if (
+                    not member_agent.store_media
+                    or not member_agent.store_tool_messages
+                    or not member_agent.store_history_messages
+                ):
+                    member_agent._scrub_run_output_for_storage(member_agent_run_response)  # type: ignore
+
+                # Add the member run to the team session
                 session.upsert_run(member_agent_run_response)
 
             # Update team session state
@@ -6287,7 +6999,7 @@ class Team:
                 done_marker = object()
                 queue: "asyncio.Queue[Union[RunOutputEvent, TeamRunOutputEvent, str, object]]" = asyncio.Queue()
 
-                async def stream_member(agent: Union[Agent, "Team"], idx: int) -> None:
+                async def stream_member(agent: Union[Agent, "Team"]) -> None:
                     member_agent_task, history = _setup_delegate_task_to_member(
                         agent, task_description, expected_output
                     )
@@ -6335,11 +7047,10 @@ class Team:
 
                 # Initialize and launch all members
                 tasks: List[asyncio.Task[None]] = []
-                for member_agent_index, member_agent in enumerate(self.members):
+                for member_agent in self.members:
                     current_agent = member_agent
-                    current_index = member_agent_index
                     self._initialize_member(current_agent)
-                    tasks.append(asyncio.create_task(stream_member(current_agent, current_index)))
+                    tasks.append(asyncio.create_task(stream_member(current_agent)))
 
                 # Drain queue until all members reported done
                 completed = 0
@@ -6364,7 +7075,6 @@ class Team:
                 tasks = []
                 for member_agent_index, member_agent in enumerate(self.members):
                     current_agent = member_agent
-                    current_index = member_agent_index
                     member_agent_task, history = _setup_delegate_task_to_member(
                         current_agent, task_description, expected_output
                     )
@@ -6467,6 +7177,18 @@ class Team:
             log_warning(f"Error getting session from db: {e}")
             return None
 
+    async def _aread_session(self, session_id: str) -> Optional[TeamSession]:
+        """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)
+            return session  # type: ignore
+        except Exception as e:
+            log_warning(f"Error getting session from db: {e}")
+            return None
+
     def _upsert_session(self, session: TeamSession) -> Optional[TeamSession]:
         """Upsert a Session into the database."""
 
@@ -6478,6 +7200,17 @@ class Team:
             log_warning(f"Error upserting session into db: {e}")
         return None
 
+    async def _aupsert_session(self, session: TeamSession) -> Optional[TeamSession]:
+        """Upsert a Session into the database."""
+
+        try:
+            if not self.db:
+                raise ValueError("Db not initialized")
+            return await self.db.upsert_session(session=session)  # type: ignore
+        except Exception as e:
+            log_warning(f"Error upserting session into db: {e}")
+        return None
+
     def get_run_output(
         self, run_id: str, session_id: Optional[str] = None
     ) -> Optional[Union[TeamRunOutput, RunOutput]]:
@@ -6567,6 +7300,47 @@ class Team:
 
         return team_session
 
+    async def _aread_or_create_session(self, session_id: str, user_id: Optional[str] = None) -> TeamSession:
+        """Load the TeamSession from storage
+
+        Returns:
+            Optional[TeamSession]: The loaded TeamSession or None if not found.
+        """
+        from time import time
+
+        from agno.session.team import TeamSession
+
+        # Return existing session if we have one
+        if self._team_session is not None and self._team_session.session_id == session_id:
+            return self._team_session
+
+        # Try to load from database
+        team_session = None
+        if self.db is not None and self.parent_team_id is None and self.workflow_id is None:
+            if self._has_async_db():
+                team_session = cast(TeamSession, await self._aread_session(session_id=session_id))
+            else:
+                team_session = cast(TeamSession, self._read_session(session_id=session_id))
+
+        # Create new session if none found
+        if team_session is None:
+            log_debug(f"Creating new TeamSession: {session_id}")
+            team_session = TeamSession(
+                session_id=session_id,
+                team_id=self.id,
+                user_id=user_id,
+                team_data=self._get_team_data(),
+                session_data={},
+                metadata=self.metadata,
+                created_at=int(time()),
+            )
+
+        # Cache the session if relevant
+        if team_session is not None and self.cache_session:
+            self._team_session = team_session
+
+        return team_session
+
     def get_session(
         self,
         session_id: Optional[str] = None,
@@ -6610,14 +7384,29 @@ class Team:
                 session.session_data["session_state"].pop("current_user_id", None)  # type: ignore
                 session.session_data["session_state"].pop("current_run_id", None)  # type: ignore
 
-            # scrub the member responses if not storing them
-            if not self.store_member_responses and session.runs is not None:
+            # scrub the member responses based on storage settings
+            if session.runs is not None:
                 for run in session.runs:
                     if hasattr(run, "member_responses"):
-                        run.member_responses = []
+                        if not self.store_member_responses:
+                            # Remove all member responses
+                            run.member_responses = []
+                        else:
+                            # Scrub individual member responses based on their storage flags
+                            self._scrub_member_responses(run.member_responses)
             self._upsert_session(session=session)
             log_debug(f"Created or updated TeamSession record: {session.session_id}")
 
+    async def asave_session(self, session: TeamSession) -> None:
+        """Save the TeamSession to storage"""
+        if self.db is not None and self.parent_team_id is None and self.workflow_id is None:
+            if session.session_data is not None and "session_state" in session.session_data:
+                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)
+            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]:
         """Load and return the stored session_state from the database, optionally merging it with the given one"""