agno 2.2.5__py3-none-any.whl → 2.2.7__py3-none-any.whl

agno/team/team.py

@@ -45,9 +45,10 @@ from agno.models.base import Model
 from agno.models.message import Message, MessageReferences
 from agno.models.metrics import Metrics
 from agno.models.response import ModelResponse, ModelResponseEvent
+from agno.models.utils import get_model
 from agno.reasoning.step import NextAction, ReasoningStep, ReasoningSteps
+from agno.run import RunContext, RunStatus
 from agno.run.agent import RunEvent, RunOutput, RunOutputEvent
-from agno.run.base import RunStatus
 from agno.run.cancel import (
     cancel_run as cancel_run_global,
 )
@@ -87,7 +88,9 @@ from agno.utils.agent import (
     scrub_media_from_run_output,
     scrub_tool_results_from_run_output,
     set_session_name_util,
+    store_media_util,
     update_session_state_util,
+    validate_media_object_id,
     wait_for_background_tasks,
     wait_for_background_tasks_stream,
 )
@@ -335,9 +338,9 @@ class Team:
 
     # --- Team Hooks ---
     # Functions called right after team session is loaded, before processing starts
-    pre_hooks: Optional[Union[List[Callable[..., Any]], List[BaseGuardrail]]] = None
+    pre_hooks: Optional[List[Union[Callable[..., Any], BaseGuardrail]]] = None
     # Functions called after output is generated but before the response is returned
-    post_hooks: Optional[Union[List[Callable[..., Any]], List[BaseGuardrail]]] = None
+    post_hooks: Optional[List[Union[Callable[..., Any], BaseGuardrail]]] = None
 
     # --- Structured output ---
     # Input schema for validating input
@@ -437,7 +440,7 @@ class Team:
         self,
         members: List[Union[Agent, "Team"]],
         id: Optional[str] = None,
-        model: Optional[Model] = None,
+        model: Optional[Union[Model, str]] = None,
         name: Optional[str] = None,
         role: Optional[str] = None,
         respond_directly: bool = False,
@@ -494,13 +497,13 @@ class Team:
         tool_call_limit: Optional[int] = None,
         tool_choice: Optional[Union[str, Dict[str, Any]]] = None,
         tool_hooks: Optional[List[Callable]] = None,
-        pre_hooks: Optional[Union[List[Callable[..., Any]], List[BaseGuardrail]]] = None,
-        post_hooks: Optional[Union[List[Callable[..., Any]], List[BaseGuardrail]]] = None,
+        pre_hooks: Optional[List[Union[Callable[..., Any], BaseGuardrail]]] = None,
+        post_hooks: Optional[List[Union[Callable[..., Any], BaseGuardrail]]] = None,
         input_schema: Optional[Type[BaseModel]] = None,
         output_schema: Optional[Type[BaseModel]] = None,
-        parser_model: Optional[Model] = None,
+        parser_model: Optional[Union[Model, str]] = None,
         parser_model_prompt: Optional[str] = None,
-        output_model: Optional[Model] = None,
+        output_model: Optional[Union[Model, str]] = None,
         output_model_prompt: Optional[str] = None,
         use_json_mode: bool = False,
         parse_response: bool = True,
@@ -514,7 +517,7 @@ class Team:
         add_session_summary_to_context: Optional[bool] = None,
         metadata: Optional[Dict[str, Any]] = None,
         reasoning: bool = False,
-        reasoning_model: Optional[Model] = None,
+        reasoning_model: Optional[Union[Model, str]] = None,
         reasoning_agent: Optional[Agent] = None,
         reasoning_min_steps: int = 1,
         reasoning_max_steps: int = 10,
@@ -535,7 +538,7 @@ class Team:
     ):
         self.members = members
 
-        self.model = model
+        self.model = model  # type: ignore[assignment]
 
         self.name = name
         self.id = id
@@ -618,9 +621,9 @@ class Team:
 
         self.input_schema = input_schema
         self.output_schema = output_schema
-        self.parser_model = parser_model
+        self.parser_model = parser_model  # type: ignore[assignment]
         self.parser_model_prompt = parser_model_prompt
-        self.output_model = output_model
+        self.output_model = output_model  # type: ignore[assignment]
         self.output_model_prompt = output_model_prompt
         self.use_json_mode = use_json_mode
         self.parse_response = parse_response
@@ -637,7 +640,7 @@ class Team:
         self.metadata = metadata
 
         self.reasoning = reasoning
-        self.reasoning_model = reasoning_model
+        self.reasoning_model = reasoning_model  # type: ignore[assignment]
         self.reasoning_agent = reasoning_agent
         self.reasoning_min_steps = reasoning_min_steps
         self.reasoning_max_steps = reasoning_max_steps
@@ -694,6 +697,8 @@ class Team:
         # Lazy-initialized shared thread pool executor for background tasks (memory, cultural knowledge, etc.)
         self._background_executor: Optional[Any] = None
 
+        self._resolve_models()
+
     @property
     def background_executor(self) -> Any:
         """Lazy initialization of shared thread pool executor for background tasks.
@@ -902,6 +907,17 @@ class Team:
         """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 _resolve_models(self) -> None:
+        """Resolve model strings to Model instances."""
+        if self.model is not None:
+            self.model = get_model(self.model)
+        if self.reasoning_model is not None:
+            self.reasoning_model = get_model(self.reasoning_model)
+        if self.parser_model is not None:
+            self.parser_model = get_model(self.parser_model)
+        if self.output_model is not None:
+            self.output_model = get_model(self.output_model)
+
     def initialize_team(self, debug_mode: Optional[bool] = None) -> None:
         # Make sure for the team, we are using the team logger
         use_team_logger()
@@ -976,9 +992,7 @@ class Team:
         run_response: TeamRunOutput,
         run_input: TeamRunInput,
         session: TeamSession,
-        session_state: Optional[Dict[str, Any]] = None,
-        dependencies: Optional[Dict[str, Any]] = None,
-        metadata: Optional[Dict[str, Any]] = None,
+        run_context: RunContext,
         user_id: Optional[str] = None,
         debug_mode: Optional[bool] = None,
         **kwargs: Any,
@@ -990,12 +1004,13 @@ class Team:
         # Prepare all possible arguments once
         all_args = {
             "run_input": run_input,
+            "run_context": run_context,
             "team": self,
             "session": session,
             "user_id": user_id,
-            "metadata": metadata,
-            "session_state": session_state,
-            "dependencies": dependencies,
+            "metadata": run_context.metadata,
+            "session_state": run_context.session_state,
+            "dependencies": run_context.dependencies,
             "debug_mode": debug_mode or self.debug_mode,
         }
         all_args.update(kwargs)
@@ -1042,9 +1057,7 @@ class Team:
         run_response: TeamRunOutput,
         run_input: TeamRunInput,
         session: TeamSession,
-        session_state: Optional[Dict[str, Any]] = None,
-        dependencies: Optional[Dict[str, Any]] = None,
-        metadata: Optional[Dict[str, Any]] = None,
+        run_context: RunContext,
         user_id: Optional[str] = None,
         debug_mode: Optional[bool] = None,
         **kwargs: Any,
@@ -1056,12 +1069,13 @@ class Team:
         # Prepare all possible arguments once
         all_args = {
             "run_input": run_input,
+            "run_context": run_context,
             "team": self,
             "session": session,
             "user_id": user_id,
-            "session_state": session_state,
-            "dependencies": dependencies,
-            "metadata": metadata,
+            "session_state": run_context.session_state,
+            "dependencies": run_context.dependencies,
+            "metadata": run_context.metadata,
             "debug_mode": debug_mode or self.debug_mode,
         }
         all_args.update(kwargs)
@@ -1113,9 +1127,7 @@ class Team:
         hooks: Optional[List[Callable[..., Any]]],
         run_output: TeamRunOutput,
         session: TeamSession,
-        session_state: Optional[Dict[str, Any]] = None,
-        dependencies: Optional[Dict[str, Any]] = None,
-        metadata: Optional[Dict[str, Any]] = None,
+        run_context: RunContext,
         user_id: Optional[str] = None,
         debug_mode: Optional[bool] = None,
         **kwargs: Any,
@@ -1127,12 +1139,13 @@ class Team:
         # Prepare all possible arguments once
         all_args = {
             "run_output": run_output,
+            "run_context": run_context,
             "team": self,
             "session": session,
             "user_id": user_id,
-            "session_state": session_state,
-            "dependencies": dependencies,
-            "metadata": metadata,
+            "session_state": run_context.session_state,
+            "dependencies": run_context.dependencies,
+            "metadata": run_context.metadata,
             "debug_mode": debug_mode or self.debug_mode,
         }
         all_args.update(kwargs)
@@ -1174,10 +1187,8 @@ class Team:
         hooks: Optional[List[Callable[..., Any]]],
         run_output: TeamRunOutput,
         session: TeamSession,
+        run_context: RunContext,
         user_id: Optional[str] = None,
-        session_state: Optional[Dict[str, Any]] = None,
-        dependencies: Optional[Dict[str, Any]] = None,
-        metadata: Optional[Dict[str, Any]] = None,
         debug_mode: Optional[bool] = None,
         **kwargs: Any,
     ) -> AsyncIterator[TeamRunOutputEvent]:
@@ -1188,12 +1199,13 @@ class Team:
         # Prepare all possible arguments once
         all_args = {
             "run_output": run_output,
+            "run_context": run_context,
             "team": self,
             "session": session,
             "user_id": user_id,
-            "session_state": session_state,
-            "dependencies": dependencies,
-            "metadata": metadata,
+            "session_state": run_context.session_state,
+            "dependencies": run_context.dependencies,
+            "metadata": run_context.metadata,
             "debug_mode": debug_mode or self.debug_mode,
         }
         all_args.update(kwargs)
@@ -1238,15 +1250,12 @@ class Team:
         self,
         run_response: TeamRunOutput,
         session: TeamSession,
-        session_state: Dict[str, Any],
+        run_context: RunContext,
         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,
         debug_mode: Optional[bool] = None,
         **kwargs: Any,
     ) -> TeamRunOutput:
@@ -1280,10 +1289,8 @@ class Team:
                 hooks=self.pre_hooks,  # type: ignore
                 run_response=run_response,
                 run_input=run_input,
+                run_context=run_context,
                 session=session,
-                session_state=session_state,
-                dependencies=dependencies,
-                metadata=metadata,
                 user_id=user_id,
                 debug_mode=debug_mode,
                 **kwargs,
@@ -1298,12 +1305,11 @@ class Team:
         _tools = self._determine_tools_for_model(
             model=self.model,
             run_response=run_response,
+            run_context=run_context,
             team_run_context=team_run_context,
             session=session,
-            session_state=session_state,
             user_id=user_id,
             async_mode=False,
-            knowledge_filters=knowledge_filters,
             input_message=run_input.input_content,
             images=run_input.images,
             videos=run_input.videos,
@@ -1312,28 +1318,23 @@ class Team:
             debug_mode=debug_mode,
             add_history_to_context=add_history_to_context,
             add_session_state_to_context=add_session_state_to_context,
-            dependencies=dependencies,
             add_dependencies_to_context=add_dependencies_to_context,
-            metadata=metadata,
         )
 
         # 3. Prepare run messages
         run_messages: RunMessages = self._get_run_messages(
             run_response=run_response,
             session=session,
-            session_state=session_state,
+            run_context=run_context,
             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,
-            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,
             tools=_tools,
             **kwargs,
         )
@@ -1386,7 +1387,7 @@ class Team:
 
             # 8. Store media if enabled
             if self.store_media:
-                self._store_media(run_response, model_response)
+                store_media_util(run_response, model_response)
 
             # 9. Convert response to structured format
             self._convert_response_to_structured_format(run_response=run_response)
@@ -1396,10 +1397,8 @@ class Team:
                 iterator = self._execute_post_hooks(
                     hooks=self.post_hooks,  # type: ignore
                     run_output=run_response,
+                    run_context=run_context,
                     session=session,
-                    session_state=session_state,
-                    dependencies=dependencies,
-                    metadata=metadata,
                     user_id=user_id,
                     debug_mode=debug_mode,
                     **kwargs,
@@ -1451,15 +1450,12 @@ class Team:
     def _run_stream(
         self,
         run_response: TeamRunOutput,
+        run_context: RunContext,
         session: TeamSession,
-        session_state: Dict[str, Any],
         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,
-        dependencies: Optional[Dict[str, Any]] = None,
         response_format: Optional[Union[Dict, Type[BaseModel]]] = None,
         stream_events: bool = False,
         yield_run_response: bool = False,
@@ -1491,11 +1487,9 @@ class Team:
             pre_hook_iterator = self._execute_pre_hooks(
                 hooks=self.pre_hooks,  # type: ignore
                 run_response=run_response,
+                run_context=run_context,
                 run_input=run_input,
                 session=session,
-                session_state=session_state,
-                dependencies=dependencies,
-                metadata=metadata,
                 user_id=user_id,
                 debug_mode=debug_mode,
                 **kwargs,
@@ -1510,12 +1504,11 @@ class Team:
         _tools = self._determine_tools_for_model(
             model=self.model,
             run_response=run_response,
+            run_context=run_context,
             team_run_context=team_run_context,
             session=session,
-            session_state=session_state,
             user_id=user_id,
             async_mode=False,
-            knowledge_filters=knowledge_filters,
             input_message=run_input.input_content,
             images=run_input.images,
             videos=run_input.videos,
@@ -1524,28 +1517,23 @@ class Team:
             debug_mode=debug_mode,
             add_history_to_context=add_history_to_context,
             add_session_state_to_context=add_session_state_to_context,
-            dependencies=dependencies,
             add_dependencies_to_context=add_dependencies_to_context,
-            metadata=metadata,
         )
 
         # 3. Prepare run messages
         run_messages: RunMessages = self._get_run_messages(
             run_response=run_response,
+            run_context=run_context,
             session=session,
-            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,
-            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,
             tools=_tools,
             **kwargs,
         )
@@ -1593,6 +1581,7 @@ class Team:
                     tools=_tools,
                     response_format=response_format,
                     stream_events=stream_events,
+                    session_state=run_context.session_state,
                 ):
                     raise_if_cancelled(run_response.run_id)  # type: ignore
                     yield event
@@ -1604,6 +1593,7 @@ class Team:
                     tools=_tools,
                     response_format=response_format,
                     stream_events=stream_events,
+                    session_state=run_context.session_state,
                 ):
                     raise_if_cancelled(run_response.run_id)  # type: ignore
                     from agno.run.team import IntermediateRunContentEvent, RunContentEvent
@@ -1647,9 +1637,7 @@ class Team:
                 yield from self._execute_post_hooks(
                     hooks=self.post_hooks,  # type: ignore
                     run_output=run_response,
-                    session_state=session_state,
-                    dependencies=dependencies,
-                    metadata=metadata,
+                    run_context=run_context,
                     session=session,
                     user_id=user_id,
                     debug_mode=debug_mode,
@@ -1840,14 +1828,14 @@ class Team:
         # Normalise hook & guardails
         if not self._hooks_normalised:
             if self.pre_hooks:
-                self.pre_hooks = normalize_hooks(self.pre_hooks)
+                self.pre_hooks = normalize_hooks(self.pre_hooks)  # type: ignore
             if self.post_hooks:
-                self.post_hooks = normalize_hooks(self.post_hooks)
+                self.post_hooks = normalize_hooks(self.post_hooks)  # type: ignore
             self._hooks_normalised = True
 
         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(
+        image_artifacts, video_artifacts, audio_artifacts, file_artifacts = validate_media_object_id(
             images=images, videos=videos, audios=audio, files=files
         )
 
@@ -1872,11 +1860,20 @@ class Team:
         session_state = self._load_session_state(session=team_session, session_state=session_state)
 
         # Determine runtime dependencies
-        run_dependencies = dependencies if dependencies is not None else self.dependencies
+        dependencies = dependencies if dependencies is not None else self.dependencies
+
+        # Initialize run context
+        run_context = RunContext(
+            run_id=run_id,
+            session_id=session_id,
+            user_id=user_id,
+            session_state=session_state,
+            dependencies=dependencies,
+        )
 
         # Resolve callable dependencies if present
-        if run_dependencies is not None:
-            self._resolve_run_dependencies(run_dependencies)
+        if run_context.dependencies is not None:
+            self._resolve_run_dependencies(run_context=run_context)
 
         # Determine runtime context parameters
         add_dependencies = (
@@ -1889,12 +1886,9 @@ class Team:
         )
         add_history = add_history_to_context if add_history_to_context is not None else self.add_history_to_context
 
-        # Initialize Knowledge Filters
-        effective_filters = knowledge_filters
-
         # When filters are passed manually
         if self.knowledge_filters or knowledge_filters:
-            effective_filters = self._get_effective_filters(knowledge_filters)
+            run_context.knowledge_filters = self._get_effective_filters(knowledge_filters)
 
         # Use stream override value when necessary
         if stream is None:
@@ -1925,13 +1919,18 @@ class Team:
             else:
                 merge_dictionaries(metadata, self.metadata)
 
+        if metadata:
+            run_context.metadata = metadata
+
         # Create a new run_response for this attempt
         run_response = TeamRunOutput(
             run_id=run_id,
             session_id=session_id,
+            user_id=user_id,
             team_id=self.id,
             team_name=self.name,
-            metadata=metadata,
+            metadata=run_context.metadata,
+            session_state=run_context.session_state,
             input=run_input,
         )
 
@@ -1957,15 +1956,12 @@ class Team:
                 if stream:
                     response_iterator = self._run_stream(
                         run_response=run_response,
+                        run_context=run_context,
                         session=team_session,
-                        session_state=session_state,
                         user_id=user_id,
-                        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,
-                        dependencies=run_dependencies,
                         response_format=response_format,
                         stream_events=stream_events,
                         yield_run_response=yield_run_response,
@@ -1977,15 +1973,12 @@ class Team:
                 else:
                     return self._run(
                         run_response=run_response,
+                        run_context=run_context,
                         session=team_session,
-                        session_state=session_state,
                         user_id=user_id,
-                        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,
-                        dependencies=run_dependencies,
                         response_format=response_format,
                         debug_mode=debug_mode,
                         **kwargs,
@@ -2037,17 +2030,14 @@ class Team:
     async def _arun(
         self,
         run_response: TeamRunOutput,
+        run_context: RunContext,
         session_id: str,
-        session_state: Optional[Dict[str, Any]] = None,
         user_id: Optional[str] = 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,
         debug_mode: Optional[bool] = None,
-        dependencies: Optional[Dict[str, Any]] = None,
         **kwargs: Any,
     ) -> TeamRunOutput:
         """Run the Team and return the response.
@@ -2073,8 +2063,8 @@ class Team:
 
         register_run(run_response.run_id)  # type: ignore
 
-        if dependencies is not None:
-            await self._aresolve_run_dependencies(dependencies=dependencies)
+        if run_context.dependencies is not None:
+            await self._aresolve_run_dependencies(run_context=run_context)
 
         # 1. Read or create session. Reads from the database if provided.
         if self._has_async_db():
@@ -2085,11 +2075,17 @@ 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
+        run_context.session_state = self._initialize_session_state(
+            session_state=run_context.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
+        if run_context.session_state is not None:
+            run_context.session_state = self._load_session_state(
+                session=team_session, session_state=run_context.session_state
+            )
 
         run_input = cast(TeamRunInput, run_response.input)
 
@@ -2098,13 +2094,11 @@ class Team:
             pre_hook_iterator = self._aexecute_pre_hooks(
                 hooks=self.pre_hooks,  # type: ignore
                 run_response=run_response,
+                run_context=run_context,
                 run_input=run_input,
                 session=team_session,
                 user_id=user_id,
                 debug_mode=debug_mode,
-                session_state=session_state,
-                dependencies=dependencies,
-                metadata=metadata,
                 **kwargs,
             )
 
@@ -2119,12 +2113,11 @@ class Team:
         _tools = self._determine_tools_for_model(
             model=self.model,
             run_response=run_response,
+            run_context=run_context,
             team_run_context=team_run_context,
             session=team_session,
-            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,
@@ -2134,27 +2127,22 @@ class Team:
             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,
         )
 
         # 5. Prepare run messages
         run_messages = await self._aget_run_messages(
             run_response=run_response,
+            run_context=run_context,
             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,
-            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,
             tools=_tools,
             **kwargs,
         )
@@ -2187,6 +2175,7 @@ class Team:
                 tool_call_limit=self.tool_call_limit,
                 response_format=response_format,
                 send_media_to_model=self.send_media_to_model,
+                run_response=run_response,
             )  # type: ignore
 
             # Check for cancellation after model call
@@ -2205,7 +2194,7 @@ class Team:
 
             # 10. Store media if enabled
             if self.store_media:
-                self._store_media(run_response, model_response)
+                store_media_util(run_response, model_response)
 
             # 11. Convert response to structured format
             self._convert_response_to_structured_format(run_response=run_response)
@@ -2215,10 +2204,8 @@ class Team:
                 async for _ in self._aexecute_post_hooks(
                     hooks=self.post_hooks,  # type: ignore
                     run_output=run_response,
+                    run_context=run_context,
                     session=team_session,
-                    session_state=session_state,
-                    dependencies=dependencies,
-                    metadata=metadata,
                     user_id=user_id,
                     debug_mode=debug_mode,
                     **kwargs,
@@ -2277,8 +2264,8 @@ class Team:
     async def _arun_stream(
         self,
         run_response: TeamRunOutput,
+        run_context: RunContext,
         session_id: str,
-        session_state: Optional[Dict[str, Any]] = None,
         user_id: Optional[str] = None,
         response_format: Optional[Union[Dict, Type[BaseModel]]] = None,
         stream_events: bool = False,
@@ -2287,10 +2274,7 @@ class Team:
         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,
         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.
@@ -2312,8 +2296,8 @@ class Team:
         """
 
         # 1. Resolve dependencies
-        if dependencies is not None:
-            await self._aresolve_run_dependencies(dependencies=dependencies)
+        if run_context.dependencies is not None:
+            await self._aresolve_run_dependencies(run_context=run_context)
 
         # 2. Read or create session. Reads from the database if provided.
         if self._has_async_db():
@@ -2324,11 +2308,17 @@ 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
+        run_context.session_state = self._initialize_session_state(
+            session_state=run_context.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
+        if run_context.session_state is not None:
+            run_context.session_state = self._load_session_state(
+                session=team_session, session_state=run_context.session_state
+            )  # type: ignore
 
         # 4. Execute pre-hooks
         run_input = cast(TeamRunInput, run_response.input)
@@ -2337,13 +2327,11 @@ class Team:
             pre_hook_iterator = self._aexecute_pre_hooks(
                 hooks=self.pre_hooks,  # type: ignore
                 run_response=run_response,
+                run_context=run_context,
                 run_input=run_input,
                 session=team_session,
                 user_id=user_id,
                 debug_mode=debug_mode,
-                session_state=session_state,
-                dependencies=dependencies,
-                metadata=metadata,
                 **kwargs,
             )
             async for pre_hook_event in pre_hook_iterator:
@@ -2356,12 +2344,11 @@ class Team:
         _tools = self._determine_tools_for_model(
             model=self.model,
             run_response=run_response,
+            run_context=run_context,
             team_run_context=team_run_context,
             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,
@@ -2369,27 +2356,22 @@ class Team:
             files=run_input.files,
             debug_mode=debug_mode,
             add_history_to_context=add_history_to_context,
-            dependencies=dependencies,
-            metadata=metadata,
         )
 
         # 6. Prepare run messages
         run_messages = await self._aget_run_messages(
             run_response=run_response,
+            run_context=run_context,
             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,
-            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,
             tools=_tools,
             **kwargs,
         )
@@ -2439,6 +2421,7 @@ class Team:
                     tools=_tools,
                     response_format=response_format,
                     stream_events=stream_events,
+                    session_state=run_context.session_state,
                 ):
                     raise_if_cancelled(run_response.run_id)  # type: ignore
                     yield event
@@ -2450,6 +2433,7 @@ class Team:
                     tools=_tools,
                     response_format=response_format,
                     stream_events=stream_events,
+                    session_state=run_context.session_state,
                 ):
                     raise_if_cancelled(run_response.run_id)  # type: ignore
                     from agno.run.team import IntermediateRunContentEvent, RunContentEvent
@@ -2495,9 +2479,7 @@ class Team:
                 async for event in self._aexecute_post_hooks(
                     hooks=self.post_hooks,  # type: ignore
                     run_output=run_response,
-                    session_state=session_state,
-                    dependencies=dependencies,
-                    metadata=metadata,
+                    run_context=run_context,
                     session=team_session,
                     user_id=user_id,
                     debug_mode=debug_mode,
@@ -2694,9 +2676,9 @@ class Team:
         # Normalise hook & guardails
         if not self._hooks_normalised:
             if self.pre_hooks:
-                self.pre_hooks = normalize_hooks(self.pre_hooks, async_mode=True)
+                self.pre_hooks = normalize_hooks(self.pre_hooks, async_mode=True)  # type: ignore
             if self.post_hooks:
-                self.post_hooks = normalize_hooks(self.post_hooks, async_mode=True)
+                self.post_hooks = normalize_hooks(self.post_hooks, async_mode=True)  # type: ignore
             self._hooks_normalised = True
 
         session_id, user_id = self._initialize_session(session_id=session_id, user_id=user_id)
@@ -2704,12 +2686,12 @@ class Team:
         # Initialize Team
         self.initialize_team(debug_mode=debug_mode)
 
-        image_artifacts, video_artifacts, audio_artifacts, file_artifacts = self._validate_media_object_id(
+        image_artifacts, video_artifacts, audio_artifacts, file_artifacts = validate_media_object_id(
             images=images, videos=videos, audios=audio, files=files
         )
 
         # Resolve variables
-        run_dependencies = dependencies if dependencies is not None else self.dependencies
+        dependencies = dependencies if dependencies is not None else self.dependencies
         add_dependencies = (
             add_dependencies_to_context if add_dependencies_to_context is not None else self.add_dependencies_to_context
         )
@@ -2764,13 +2746,26 @@ class Team:
         if self.knowledge_filters or knowledge_filters:
             effective_filters = self._get_effective_filters(knowledge_filters)
 
+        # Initialize run context
+        run_context = RunContext(
+            run_id=run_id,
+            session_id=session_id,
+            user_id=user_id,
+            session_state=session_state,
+            dependencies=dependencies,
+            knowledge_filters=effective_filters,
+            metadata=metadata,
+        )
+
         # Create a new run_response for this attempt
         run_response = TeamRunOutput(
             run_id=run_id,
+            user_id=user_id,
             session_id=session_id,
             team_id=self.id,
             team_name=self.name,
-            metadata=metadata,
+            metadata=run_context.metadata,
+            session_state=run_context.session_state,
             input=run_input,
         )
 
@@ -2795,16 +2790,13 @@ class Team:
                     response_iterator = self._arun_stream(
                         input=validated_input,
                         run_response=run_response,
+                        run_context=run_context,
                         session_id=session_id,
-                        session_state=session_state,
                         user_id=user_id,
-                        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,
                         stream_events=stream_events,
                         yield_run_response=yield_run_response,
                         debug_mode=debug_mode,
@@ -2815,17 +2807,14 @@ class Team:
                     return self._arun(  # type: ignore
                         input=validated_input,
                         run_response=run_response,
+                        run_context=run_context,
                         session_id=session_id,
-                        session_state=session_state,
                         user_id=user_id,
-                        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,
                         debug_mode=debug_mode,
-                        dependencies=run_dependencies,
                         **kwargs,
                     )
 
@@ -2871,25 +2860,6 @@ class Team:
 
             raise Exception(f"Failed after {num_attempts} attempts.")
 
-    def _store_media(self, run_response: TeamRunOutput, model_response: ModelResponse):
-        """Store media from model response in run_response for persistence"""
-        # Handle generated media fields from ModelResponse (generated media)
-        if model_response.images is not None:
-            for image in model_response.images:
-                self._add_image(image, run_response)  # Generated images go to run_response.images
-
-        if model_response.videos is not None:
-            for video in model_response.videos:
-                self._add_video(video, run_response)  # Generated videos go to run_response.videos
-
-        if model_response.audios is not None:
-            for audio in model_response.audios:
-                self._add_audio(audio, run_response)  # Generated audio go to run_response.audio
-
-        if model_response.files is not None:
-            for file in model_response.files:
-                self._add_file(file, run_response)  # Generated files go to run_response.files
-
     def _update_run_response(
         self, model_response: ModelResponse, run_response: TeamRunOutput, run_messages: RunMessages
     ):
@@ -2930,6 +2900,12 @@ class Team:
         if model_response.audio is not None:
             run_response.response_audio = model_response.audio
 
+        # Update session_state with changes from model response
+        if model_response.updated_session_state is not None and run_response.session_state is not None:
+            from agno.utils.merge_dict import merge_dictionaries
+
+            merge_dictionaries(run_response.session_state, model_response.updated_session_state)
+
         # Build a list of messages that should be added to the RunOutput
         messages_for_run_response = [m for m in run_messages.messages if m.add_to_agent_memory]
 
@@ -2954,6 +2930,7 @@ class Team:
         tools: Optional[List[Union[Function, dict]]] = None,
         response_format: Optional[Union[Dict, Type[BaseModel]]] = None,
         stream_events: bool = False,
+        session_state: Optional[Dict[str, Any]] = None,
     ) -> Iterator[Union[TeamRunOutputEvent, RunOutputEvent]]:
         self.model = cast(Model, self.model)
 
@@ -2985,6 +2962,7 @@ class Team:
                 reasoning_state=reasoning_state,
                 stream_events=stream_events,
                 parse_structured_output=self.should_parse_structured_output,
+                session_state=session_state,
             )
 
         # 3. Update TeamRunOutput
@@ -3036,6 +3014,7 @@ class Team:
         tools: Optional[List[Union[Function, dict]]] = None,
         response_format: Optional[Union[Dict, Type[BaseModel]]] = None,
         stream_events: bool = False,
+        session_state: Optional[Dict[str, Any]] = None,
     ) -> AsyncIterator[Union[TeamRunOutputEvent, RunOutputEvent]]:
         self.model = cast(Model, self.model)
 
@@ -3058,6 +3037,7 @@ class Team:
             tool_call_limit=self.tool_call_limit,
             stream_model_response=stream_model_response,
             send_media_to_model=self.send_media_to_model,
+            run_response=run_response,
         )  # type: ignore
         async for model_response_event in model_stream:
             for event in self._handle_model_response_chunk(
@@ -3068,6 +3048,7 @@ class Team:
                 reasoning_state=reasoning_state,
                 stream_events=stream_events,
                 parse_structured_output=self.should_parse_structured_output,
+                session_state=session_state,
             ):
                 yield event
 
@@ -3122,6 +3103,7 @@ class Team:
         reasoning_state: Optional[Dict[str, Any]] = None,
         stream_events: bool = False,
         parse_structured_output: bool = False,
+        session_state: Optional[Dict[str, Any]] = None,
     ) -> Iterator[Union[TeamRunOutputEvent, RunOutputEvent]]:
         if isinstance(model_response_event, tuple(get_args(RunOutputEvent))) or isinstance(
             model_response_event, tuple(get_args(TeamRunOutputEvent))
@@ -3241,7 +3223,9 @@ class Team:
 
                 if model_response_event.images is not None:
                     for image in model_response_event.images:
-                        self._add_image(image, run_response)
+                        if run_response.images is None:
+                            run_response.images = []
+                        run_response.images.append(image)
 
                     should_yield = True
 
@@ -3299,22 +3283,39 @@ class Team:
 
             # If the model response is a tool_call_completed, update the existing tool call in the run_response
             elif model_response_event.event == ModelResponseEvent.tool_call_completed.value:
-                if model_response_event.updated_session_state is not None and session.session_data is not None:
-                    merge_dictionaries(
-                        session.session_data["session_state"], model_response_event.updated_session_state
-                    )
+                if model_response_event.updated_session_state is not None:
+                    # Update the session_state variable that TeamRunOutput references
+                    if session_state is not None:
+                        merge_dictionaries(session_state, model_response_event.updated_session_state)
+                    # Also update the DB session object
+                    if session.session_data is not None:
+                        merge_dictionaries(
+                            session.session_data["session_state"], model_response_event.updated_session_state
+                        )
 
                 if model_response_event.images is not None:
                     for image in model_response_event.images:
-                        self._add_image(image, run_response)
+                        if run_response.images is None:
+                            run_response.images = []
+                        run_response.images.append(image)
 
                 if model_response_event.videos is not None:
                     for video in model_response_event.videos:
-                        self._add_video(video, run_response)
+                        if run_response.videos is None:
+                            run_response.videos = []
+                        run_response.videos.append(video)
 
                 if model_response_event.audios is not None:
                     for audio in model_response_event.audios:
-                        self._add_audio(audio, run_response)
+                        if run_response.audio is None:
+                            run_response.audio = []
+                        run_response.audio.append(audio)
+
+                if model_response_event.files is not None:
+                    for file_obj in model_response_event.files:
+                        if run_response.files is None:
+                            run_response.files = []
+                        run_response.files.append(file_obj)
 
                 reasoning_step: Optional[ReasoningStep] = None
                 tool_executions_list = model_response_event.tool_executions
@@ -4123,55 +4124,6 @@ class Team:
             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,
-        videos: Optional[Sequence[Video]] = None,
-        audios: Optional[Sequence[Audio]] = None,
-        files: Optional[Sequence[File]] = None,
-    ) -> tuple:
-        image_list = None
-        if images:
-            image_list = []
-            for img in images:
-                if not img.id:
-                    from uuid import uuid4
-
-                    img.id = str(uuid4())
-                image_list.append(img)
-
-        video_list = None
-        if videos:
-            video_list = []
-            for vid in videos:
-                if not vid.id:
-                    from uuid import uuid4
-
-                    vid.id = str(uuid4())
-                video_list.append(vid)
-
-        audio_list = None
-        if audios:
-            audio_list = []
-            for aud in audios:
-                if not aud.id:
-                    from uuid import uuid4
-
-                    aud.id = str(uuid4())
-                audio_list.append(aud)
-
-        file_list = None
-        if files:
-            file_list = []
-            for file in files:
-                if not file.id:
-                    from uuid import uuid4
-
-                    file.id = str(uuid4())
-                file_list.append(file)
-
-        return image_list, video_list, audio_list, file_list
-
     def cli_app(
         self,
         input: Optional[str] = None,
@@ -4498,7 +4450,7 @@ class Team:
                         store_events=self.store_events,
                     )
             else:
-                log_warning(
+                log_info(
                     f"Reasoning model: {reasoning_model.__class__.__name__} is not a native reasoning model, defaulting to manual Chain-of-Thought reasoning"
                 )
                 use_default_reasoning = True
@@ -4779,7 +4731,7 @@ class Team:
                         store_events=self.store_events,
                     )
             else:
-                log_warning(
+                log_info(
                     f"Reasoning model: {reasoning_model.__class__.__name__} is not a native reasoning model, defaulting to manual Chain-of-Thought reasoning"
                 )
                 use_default_reasoning = True
@@ -4915,38 +4867,38 @@ class Team:
                     store_events=self.store_events,
                 )
 
-    def _resolve_run_dependencies(self, dependencies: Optional[Dict[str, Any]] = None) -> None:
+    def _resolve_run_dependencies(self, run_context: RunContext) -> None:
         from inspect import signature
 
         log_debug("Resolving dependencies")
-        if not isinstance(dependencies, dict):
+        if not isinstance(run_context.dependencies, dict):
             log_warning("Dependencies is not a dict")
             return
 
-        for key, value in dependencies.items():
+        for key, value in run_context.dependencies.items():
             if not callable(value):
-                dependencies[key] = value
+                run_context.dependencies[key] = value
                 continue
 
             try:
                 sig = signature(value)
                 resolved_value = value(agent=self) if "agent" in sig.parameters else value()
 
-                dependencies[key] = resolved_value
+                run_context.dependencies[key] = resolved_value
             except Exception as e:
                 log_warning(f"Failed to resolve dependencies for {key}: {e}")
 
-    async def _aresolve_run_dependencies(self, dependencies: Optional[Dict[str, Any]] = None) -> None:
+    async def _aresolve_run_dependencies(self, run_context: RunContext) -> None:
         from inspect import iscoroutine, signature
 
         log_debug("Resolving context (async)")
-        if not isinstance(dependencies, dict):
+        if not isinstance(run_context.dependencies, dict):
             log_warning("Dependencies is not a dict")
             return
 
-        for key, value in dependencies.items():
+        for key, value in run_context.dependencies.items():
             if not callable(value):
-                dependencies[key] = value
+                run_context.dependencies[key] = value
                 continue
 
             try:
@@ -4956,7 +4908,7 @@ class Team:
                 if iscoroutine(resolved_value):
                     resolved_value = await resolved_value
 
-                dependencies[key] = resolved_value
+                run_context.dependencies[key] = resolved_value
             except Exception as e:
                 log_warning(f"Failed to resolve context for '{key}': {e}")
 
@@ -4987,12 +4939,11 @@ class Team:
         self,
         model: Model,
         run_response: TeamRunOutput,
+        run_context: RunContext,
         team_run_context: Dict[str, Any],
         session: TeamSession,
-        session_state: Dict[str, Any],
         user_id: Optional[str] = None,
         async_mode: bool = False,
-        knowledge_filters: Optional[Dict[str, Any]] = None,
         input_message: Optional[Union[str, List, Dict, Message, BaseModel, List[Message]]] = None,
         images: Optional[Sequence[Image]] = None,
         videos: Optional[Sequence[Video]] = None,
@@ -5000,10 +4951,8 @@ class Team:
         files: Optional[Sequence[File]] = None,
         debug_mode: Optional[bool] = 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,
         check_mcp_tools: bool = True,
     ) -> List[Union[Function, dict]]:
         # Prepare tools
@@ -5049,13 +4998,17 @@ class Team:
                 if self.enable_agentic_knowledge_filters:
                     _tools.append(
                         self._get_search_knowledge_base_with_agentic_filters_function(
-                            run_response=run_response, knowledge_filters=knowledge_filters, async_mode=async_mode
+                            run_response=run_response,
+                            knowledge_filters=run_context.knowledge_filters,
+                            async_mode=async_mode,
                         )
                     )
                 else:
                     _tools.append(
                         self._get_search_knowledge_base_function(
-                            run_response=run_response, knowledge_filters=knowledge_filters, async_mode=async_mode
+                            run_response=run_response,
+                            knowledge_filters=run_context.knowledge_filters,
+                            async_mode=async_mode,
                         )
                     )
 
@@ -5068,23 +5021,21 @@ class Team:
             if self.determine_input_for_members is False:
                 user_message = self._get_user_message(
                     run_response=run_response,
-                    session_state=session_state,
+                    run_context=run_context,
                     input_message=input_message,
                     user_id=user_id,
                     audio=audio,
                     images=images,
                     videos=videos,
                     files=files,
-                    dependencies=dependencies,
                     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,
+                run_context=run_context,
                 session=session,
-                session_state=session_state,
                 team_run_context=team_run_context,
                 input=user_message_content,
                 user_id=user_id,
@@ -5095,12 +5046,9 @@ class Team:
                 videos=videos,  # type: ignore
                 audio=audio,  # type: ignore
                 files=files,  # type: ignore
-                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,
                 debug_mode=debug_mode,
             )
 
@@ -5207,8 +5155,9 @@ class Team:
 
             for func in _functions:  # type: ignore
                 if isinstance(func, Function):
-                    func._session_state = session_state
-                    func._dependencies = dependencies
+                    func._run_context = run_context
+                    func._session_state = run_context.session_state
+                    func._dependencies = run_context.dependencies
                     func._images = joint_images
                     func._files = joint_files
                     func._audios = joint_audios
@@ -5251,18 +5200,30 @@ class Team:
     def get_system_message(
         self,
         session: TeamSession,
-        session_state: Optional[Dict[str, Any]] = None,
+        run_context: Optional[RunContext] = 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,
         tools: Optional[List[Union[Function, dict]]] = None,
         add_session_state_to_context: Optional[bool] = None,
+        session_state: Optional[Dict[str, Any]] = None,  # Deprecated
+        dependencies: Optional[Dict[str, Any]] = None,  # Deprecated
+        metadata: Optional[Dict[str, Any]] = None,  # Deprecated
     ) -> Optional[Message]:
-        """Get the system message for the team."""
+        """Get the system message for the team.
+
+        1. If the system_message is provided, use that.
+        2. If build_context is False, return None.
+        3. Build and return the default system message for the Team.
+        """
+
+        # Consider both run_context and session_state, dependencies, metadata (deprecated fields)
+        if run_context is not None:
+            session_state = run_context.session_state or session_state
+            dependencies = run_context.dependencies or dependencies
+            metadata = run_context.metadata or metadata
 
         # 1. If the system_message is provided, use that.
         if self.system_message is not None:
@@ -5545,19 +5506,26 @@ class Team:
     async def aget_system_message(
         self,
         session: TeamSession,
-        session_state: Optional[Dict[str, Any]] = None,
+        run_context: Optional[RunContext] = 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,
         tools: Optional[List[Union[Function, dict]]] = None,
         add_session_state_to_context: Optional[bool] = None,
+        session_state: Optional[Dict[str, Any]] = None,  # Deprecated
+        dependencies: Optional[Dict[str, Any]] = None,  # Deprecated
+        metadata: Optional[Dict[str, Any]] = None,  # Deprecated
     ) -> Optional[Message]:
         """Get the system message for the team."""
 
+        # Consider both run_context and session_state, dependencies, metadata (deprecated fields)
+        if run_context is not None:
+            session_state = run_context.session_state or session_state
+            dependencies = run_context.dependencies or dependencies
+            metadata = run_context.metadata or metadata
+
         # 1. If the system_message is provided, use that.
         if self.system_message is not None:
             if isinstance(self.system_message, Message):
@@ -5651,7 +5619,7 @@ class Team:
             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)
+            valid_filters = await self.knowledge.aget_valid_filters()
             if valid_filters:
                 valid_filters_str = ", ".join(valid_filters)
                 additional_information.append(
@@ -5827,8 +5795,8 @@ class Team:
                 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"
+        if add_session_state_to_context and session_state is not None:
+            system_message_content += self._get_formatted_session_state_for_system_message(session_state)
 
         # Add the JSON output prompt if output_schema is provided and structured_outputs is False
         if (
@@ -5848,20 +5816,17 @@ class Team:
         self,
         *,
         run_response: TeamRunOutput,
+        run_context: RunContext,
         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,
         tools: Optional[List[Union[Function, dict]]] = None,
         **kwargs: Any,
     ) -> RunMessages:
@@ -5884,14 +5849,12 @@ class Team:
         # 1. Add system message to run_messages
         system_message = self.get_system_message(
             session=session,
-            session_state=session_state,
+            run_context=run_context,
             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,
             tools=tools,
         )
@@ -5965,17 +5928,14 @@ class Team:
         # 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,
+            run_context=run_context,
             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
@@ -5989,20 +5949,17 @@ class Team:
         self,
         *,
         run_response: TeamRunOutput,
+        run_context: RunContext,
         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,
         tools: Optional[List[Union[Function, dict]]] = None,
         **kwargs: Any,
     ) -> RunMessages:
@@ -6025,14 +5982,12 @@ class Team:
         # 1. Add system message to run_messages
         system_message = await self.aget_system_message(
             session=session,
-            session_state=session_state,
+            run_context=run_context,
             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,
             tools=tools,
         )
@@ -6105,17 +6060,14 @@ class Team:
         # 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,
+            run_context=run_context,
             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
@@ -6129,17 +6081,14 @@ class Team:
         self,
         *,
         run_response: TeamRunOutput,
-        session_state: Optional[Dict[str, Any]] = None,
+        run_context: RunContext,
         input_message: Optional[Union[str, List, Dict, Message, BaseModel, List[Message]]] = 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,
-        knowledge_filters: Optional[Dict[str, Any]] = None,
-        dependencies: Optional[Dict[str, Any]] = None,
         add_dependencies_to_context: Optional[bool] = None,
-        metadata: Optional[Dict[str, Any]] = None,
         **kwargs,
     ):
         # Get references from the knowledge base to use in the user message
@@ -6223,7 +6172,7 @@ class Team:
                         retrieval_timer = Timer()
                         retrieval_timer.start()
                         docs_from_knowledge = self.get_relevant_docs_from_knowledge(
-                            query=user_msg_content, filters=knowledge_filters, **kwargs
+                            query=user_msg_content, filters=run_context.knowledge_filters, **kwargs
                         )
                         if docs_from_knowledge is not None:
                             references = MessageReferences(
@@ -6244,9 +6193,9 @@ class Team:
                     user_msg_content = self._format_message_with_state_variables(
                         user_msg_content,
                         user_id=user_id,
-                        session_state=session_state,
-                        dependencies=dependencies,
-                        metadata=metadata,
+                        session_state=run_context.session_state,
+                        dependencies=run_context.dependencies,
+                        metadata=run_context.metadata,
                     )
 
                 # Convert to string for concatenation operations
@@ -6264,9 +6213,9 @@ class Team:
                     user_msg_content_str += self._convert_documents_to_string(references.references) + "\n"
                     user_msg_content_str += "</references>"
                 # 4.2 Add context to user message
-                if add_dependencies_to_context and dependencies is not None:
+                if add_dependencies_to_context and run_context.dependencies is not None:
                     user_msg_content_str += "\n\n<additional context>\n"
-                    user_msg_content_str += self._convert_dependencies_to_string(dependencies) + "\n"
+                    user_msg_content_str += self._convert_dependencies_to_string(run_context.dependencies) + "\n"
                     user_msg_content_str += "</additional context>"
 
                 # Use the string version for the final content
@@ -6344,10 +6293,10 @@ class Team:
     def _format_message_with_state_variables(
         self,
         message: Any,
-        user_id: Optional[str] = None,
         session_state: Optional[Dict[str, Any]] = None,
         dependencies: Optional[Dict[str, Any]] = None,
         metadata: Optional[Dict[str, Any]] = None,
+        user_id: Optional[str] = None,
     ) -> Any:
         """Format a message with the session state variables."""
         import re
@@ -6853,8 +6802,8 @@ class Team:
     def _get_delegate_task_function(
         self,
         run_response: TeamRunOutput,
+        run_context: RunContext,
         session: TeamSession,
-        session_state: Dict[str, Any],
         team_run_context: Dict[str, Any],
         user_id: Optional[str] = None,
         stream: bool = False,
@@ -6865,12 +6814,9 @@ class Team:
         videos: Optional[List[Video]] = None,
         audio: Optional[List[Audio]] = None,
         files: Optional[List[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,
         debug_mode: Optional[bool] = None,
     ) -> Function:
         if not images:
@@ -6986,7 +6932,7 @@ class Team:
                 session.upsert_run(member_agent_run_response)
 
             # Update team session state
-            merge_dictionaries(session_state, member_session_state_copy)  # type: ignore
+            merge_dictionaries(run_context.session_state, member_session_state_copy)  # type: ignore
 
             # Update the team media
             if member_agent_run_response is not None:
@@ -7019,7 +6965,7 @@ class Team:
             # Make sure for the member agent, we are using the agent logger
             use_agent_logger()
 
-            member_session_state_copy = copy(session_state)
+            member_session_state_copy = copy(run_context.session_state)
 
             if stream:
                 member_agent_run_response_stream = member_agent.run(
@@ -7035,11 +6981,11 @@ class Team:
                     stream=True,
                     stream_events=stream_events,
                     debug_mode=debug_mode,
-                    dependencies=dependencies,
+                    dependencies=run_context.dependencies,
                     add_dependencies_to_context=add_dependencies_to_context,
-                    metadata=metadata,
+                    metadata=run_context.metadata,
                     add_session_state_to_context=add_session_state_to_context,
-                    knowledge_filters=knowledge_filters
+                    knowledge_filters=run_context.knowledge_filters
                     if not member_agent.knowledge_filters and member_agent.knowledge
                     else None,
                     yield_run_response=True,
@@ -7063,7 +7009,7 @@ class Team:
                     yield member_agent_run_output_event
             else:
                 member_agent_run_response = member_agent.run(  # type: ignore
-                    input=member_agent_task if not history else history,
+                    input=member_agent_task if not history else history,  # type: ignore
                     user_id=user_id,
                     # All members have the same session_id
                     session_id=session.session_id,
@@ -7074,11 +7020,11 @@ class Team:
                     files=files,
                     stream=False,
                     debug_mode=debug_mode,
-                    dependencies=dependencies,
+                    dependencies=run_context.dependencies,
                     add_dependencies_to_context=add_dependencies_to_context,
                     add_session_state_to_context=add_session_state_to_context,
-                    metadata=metadata,
-                    knowledge_filters=knowledge_filters
+                    metadata=run_context.metadata,
+                    knowledge_filters=run_context.knowledge_filters
                     if not member_agent.knowledge_filters and member_agent.knowledge
                     else None,
                 )
@@ -7116,7 +7062,10 @@ class Team:
             use_team_logger()
 
             _process_delegate_task_to_member(
-                member_agent_run_response, member_agent, member_agent_task, member_session_state_copy
+                member_agent_run_response,
+                member_agent,
+                member_agent_task,  # type: ignore
+                member_session_state_copy,  # type: ignore
             )
 
         async def adelegate_task_to_member(
@@ -7146,7 +7095,7 @@ class Team:
             # Make sure for the member agent, we are using the agent logger
             use_agent_logger()
 
-            member_session_state_copy = copy(session_state)
+            member_session_state_copy = copy(run_context.session_state)
 
             if stream:
                 member_agent_run_response_stream = member_agent.arun(  # type: ignore
@@ -7162,11 +7111,11 @@ class Team:
                     stream=True,
                     stream_events=stream_events,
                     debug_mode=debug_mode,
-                    dependencies=dependencies,
+                    dependencies=run_context.dependencies,
                     add_dependencies_to_context=add_dependencies_to_context,
                     add_session_state_to_context=add_session_state_to_context,
-                    metadata=metadata,
-                    knowledge_filters=knowledge_filters
+                    metadata=run_context.metadata,
+                    knowledge_filters=run_context.knowledge_filters
                     if not member_agent.knowledge_filters and member_agent.knowledge
                     else None,
                     yield_run_response=True,
@@ -7201,11 +7150,11 @@ class Team:
                     files=files,
                     stream=False,
                     debug_mode=debug_mode,
-                    dependencies=dependencies,
+                    dependencies=run_context.dependencies,
                     add_dependencies_to_context=add_dependencies_to_context,
                     add_session_state_to_context=add_session_state_to_context,
-                    metadata=metadata,
-                    knowledge_filters=knowledge_filters
+                    metadata=run_context.metadata,
+                    knowledge_filters=run_context.knowledge_filters
                     if not member_agent.knowledge_filters and member_agent.knowledge
                     else None,
                 )
@@ -7239,7 +7188,10 @@ class Team:
             use_team_logger()
 
             _process_delegate_task_to_member(
-                member_agent_run_response, member_agent, member_agent_task, member_session_state_copy
+                member_agent_run_response,
+                member_agent,
+                member_agent_task,  # type: ignore
+                member_session_state_copy,  # type: ignore
             )
 
         # When the task should be delegated to all members
@@ -7260,7 +7212,7 @@ class Team:
                     member_agent=member_agent, task_description=task
                 )
 
-                member_session_state_copy = copy(session_state)
+                member_session_state_copy = copy(run_context.session_state)
                 if stream:
                     member_agent_run_response_stream = member_agent.run(
                         input=member_agent_task if not history else history,
@@ -7274,14 +7226,14 @@ class Team:
                         files=files,
                         stream=True,
                         stream_events=stream_events,
-                        knowledge_filters=knowledge_filters
+                        knowledge_filters=run_context.knowledge_filters
                         if not member_agent.knowledge_filters and member_agent.knowledge
                         else None,
                         debug_mode=debug_mode,
-                        dependencies=dependencies,
+                        dependencies=run_context.dependencies,
                         add_dependencies_to_context=add_dependencies_to_context,
                         add_session_state_to_context=add_session_state_to_context,
-                        metadata=metadata,
+                        metadata=run_context.metadata,
                         yield_run_response=True,
                     )
                     member_agent_run_response = None
@@ -7314,14 +7266,14 @@ class Team:
                         audio=audio,
                         files=files,
                         stream=False,
-                        knowledge_filters=knowledge_filters
+                        knowledge_filters=run_context.knowledge_filters
                         if not member_agent.knowledge_filters and member_agent.knowledge
                         else None,
                         debug_mode=debug_mode,
-                        dependencies=dependencies,
+                        dependencies=run_context.dependencies,
                         add_dependencies_to_context=add_dependencies_to_context,
                         add_session_state_to_context=add_session_state_to_context,
-                        metadata=metadata,
+                        metadata=run_context.metadata,
                     )
 
                     check_if_run_cancelled(member_agent_run_response)  # type: ignore
@@ -7348,7 +7300,10 @@ class Team:
                         yield f"Agent {member_agent.name}: Error - {str(e)}"
 
                 _process_delegate_task_to_member(
-                    member_agent_run_response, member_agent, member_agent_task, member_session_state_copy
+                    member_agent_run_response,
+                    member_agent,
+                    member_agent_task,  # type: ignore
+                    member_session_state_copy,  # type: ignore
                 )
 
             # After all the member runs, switch back to the team logger
@@ -7374,7 +7329,7 @@ class Team:
                     member_agent_task, history = _setup_delegate_task_to_member(
                         member_agent=agent, task_description=task
                     )  # type: ignore
-                    member_session_state_copy = copy(session_state)
+                    member_session_state_copy = copy(run_context.session_state)
 
                     member_stream = agent.arun(  # type: ignore
                         input=member_agent_task if not history else history,
@@ -7388,13 +7343,13 @@ class Team:
                         stream=True,
                         stream_events=stream_events,
                         debug_mode=debug_mode,
-                        knowledge_filters=knowledge_filters
+                        knowledge_filters=run_context.knowledge_filters
                         if not member_agent.knowledge_filters and member_agent.knowledge
                         else None,
-                        dependencies=dependencies,
+                        dependencies=run_context.dependencies,
                         add_dependencies_to_context=add_dependencies_to_context,
                         add_session_state_to_context=add_session_state_to_context,
-                        metadata=metadata,
+                        metadata=run_context.metadata,
                         yield_run_response=True,
                     )
                     member_agent_run_response = None
@@ -7412,7 +7367,10 @@ class Team:
                             await queue.put(member_agent_run_output_event)
                     finally:
                         _process_delegate_task_to_member(
-                            member_agent_run_response, member_agent, member_agent_task, member_session_state_copy
+                            member_agent_run_response,
+                            member_agent,
+                            member_agent_task,  # type: ignore
+                            member_session_state_copy,  # type: ignore
                         )
                     await queue.put(done_marker)
 
@@ -7451,7 +7409,7 @@ class Team:
                     )
 
                     async def run_member_agent(agent=current_agent) -> str:
-                        member_session_state_copy = copy(session_state)
+                        member_session_state_copy = copy(run_context.session_state)
 
                         member_agent_run_response = await agent.arun(
                             input=member_agent_task if not history else history,
@@ -7466,18 +7424,21 @@ class Team:
                             stream=False,
                             stream_events=stream_events,
                             debug_mode=debug_mode,
-                            knowledge_filters=knowledge_filters
+                            knowledge_filters=run_context.knowledge_filters
                             if not member_agent.knowledge_filters and member_agent.knowledge
                             else None,
-                            dependencies=dependencies,
+                            dependencies=run_context.dependencies,
                             add_dependencies_to_context=add_dependencies_to_context,
                             add_session_state_to_context=add_session_state_to_context,
-                            metadata=metadata,
+                            metadata=run_context.metadata,
                         )
                         check_if_run_cancelled(member_agent_run_response)
 
                         _process_delegate_task_to_member(
-                            member_agent_run_response, member_agent, member_agent_task, member_session_state_copy
+                            member_agent_run_response,
+                            member_agent,
+                            member_agent_task,  # type: ignore
+                            member_session_state_copy,  # type: ignore
                         )
 
                         member_name = member_agent.name if member_agent.name else f"agent_{member_agent_index}"
@@ -8280,37 +8241,9 @@ class Team:
         return await self.memory_manager.aget_user_memories(user_id=user_id)
 
     ###########################################################################
-    # Handle images, videos and audio
+    # Handle reasoning content
     ###########################################################################
 
-    def _add_image(self, image: Image, run_response: TeamRunOutput) -> None:
-        """Add an image to both the agent's stateful storage and the current run response"""
-        # Add to run response
-        if run_response.images is None:
-            run_response.images = []
-        run_response.images.append(image)
-
-    def _add_video(self, video: Video, run_response: TeamRunOutput) -> None:
-        """Add a video to both the agent's stateful storage and the current run response"""
-        # Add to run response
-        if run_response.videos is None:
-            run_response.videos = []
-        run_response.videos.append(video)
-
-    def _add_audio(self, audio: Audio, run_response: TeamRunOutput) -> None:
-        """Add audio to both the agent's stateful storage and the current run response"""
-        # Add to run response
-        if run_response.audio is None:
-            run_response.audio = []
-        run_response.audio.append(audio)
-
-    def _add_file(self, file: File, run_response: TeamRunOutput) -> None:
-        """Add file to both the agent's stateful storage and the current run response"""
-        # Add to run response
-        if run_response.files is None:
-            run_response.files = []
-        run_response.files.append(file)
-
     def _update_reasoning_content_from_tool_call(
         self, run_response: TeamRunOutput, tool_name: str, tool_args: Dict[str, Any]
     ) -> Optional[ReasoningStep]:
@@ -8506,7 +8439,7 @@ class Team:
 
         # Validate the filters against known valid filter keys
         if self.knowledge is not None:
-            valid_filters, invalid_keys = self.knowledge.validate_filters(filters)  # type: ignore
+            valid_filters, invalid_keys = await self.knowledge.async_validate_filters(filters)  # type: ignore
 
             # Warn about invalid filter keys
             if invalid_keys: