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

agno/team/team.py

@@ -47,8 +47,8 @@ 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,
 )
@@ -88,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,
 )
@@ -336,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
@@ -495,8 +497,8 @@ 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[Union[Model, str]] = None,
@@ -990,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,
@@ -1004,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)
@@ -1056,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,
@@ -1070,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)
@@ -1127,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,
@@ -1141,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)
@@ -1188,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]:
@@ -1202,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)
@@ -1252,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:
@@ -1294,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,
@@ -1312,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,
@@ -1326,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,
         )
@@ -1400,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)
@@ -1410,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,
@@ -1465,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,
@@ -1505,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,
@@ -1524,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,
@@ -1538,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,
         )
@@ -1607,7 +1581,7 @@ class Team:
                     tools=_tools,
                     response_format=response_format,
                     stream_events=stream_events,
-                    session_state=session_state,
+                    session_state=run_context.session_state,
                 ):
                     raise_if_cancelled(run_response.run_id)  # type: ignore
                     yield event
@@ -1619,7 +1593,7 @@ class Team:
                     tools=_tools,
                     response_format=response_format,
                     stream_events=stream_events,
-                    session_state=session_state,
+                    session_state=run_context.session_state,
                 ):
                     raise_if_cancelled(run_response.run_id)  # type: ignore
                     from agno.run.team import IntermediateRunContentEvent, RunContentEvent
@@ -1663,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,
@@ -1856,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
         )
 
@@ -1888,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 = (
@@ -1905,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:
@@ -1941,14 +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,
-            session_state=session_state,
+            metadata=run_context.metadata,
+            session_state=run_context.session_state,
             input=run_input,
         )
 
@@ -1974,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,
@@ -1994,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,
@@ -2054,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.
@@ -2090,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():
@@ -2102,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)
 
@@ -2115,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,
             )
 
@@ -2136,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,
@@ -2151,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,
         )
@@ -2204,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
@@ -2222,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)
@@ -2232,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,
@@ -2294,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,
@@ -2304,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.
@@ -2329,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():
@@ -2341,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)
@@ -2354,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:
@@ -2373,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,
@@ -2386,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,
         )
@@ -2456,7 +2421,7 @@ class Team:
                     tools=_tools,
                     response_format=response_format,
                     stream_events=stream_events,
-                    session_state=session_state,
+                    session_state=run_context.session_state,
                 ):
                     raise_if_cancelled(run_response.run_id)  # type: ignore
                     yield event
@@ -2468,7 +2433,7 @@ class Team:
                     tools=_tools,
                     response_format=response_format,
                     stream_events=stream_events,
-                    session_state=session_state,
+                    session_state=run_context.session_state,
                 ):
                     raise_if_cancelled(run_response.run_id)  # type: ignore
                     from agno.run.team import IntermediateRunContentEvent, RunContentEvent
@@ -2514,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,
@@ -2713,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)
@@ -2723,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
         )
@@ -2783,14 +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,
-            session_state=session_state,
+            metadata=run_context.metadata,
+            session_state=run_context.session_state,
             input=run_input,
         )
 
@@ -2815,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,
@@ -2835,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,
                     )
 
@@ -2891,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
     ):
@@ -3087,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(
@@ -3272,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
 
@@ -3342,15 +3295,27 @@ 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)
 
                 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
@@ -4159,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,
@@ -4951,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:
@@ -4992,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}")
 
@@ -5023,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,
@@ -5036,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
@@ -5085,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,
                         )
                     )
 
@@ -5104,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,
@@ -5131,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,
             )
 
@@ -5243,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
@@ -5287,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:
@@ -5581,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):
@@ -5687,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(
@@ -5863,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 (
@@ -5884,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:
@@ -5920,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,
         )
@@ -6001,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
@@ -6025,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:
@@ -6061,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,
         )
@@ -6141,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
@@ -6165,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
@@ -6259,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(
@@ -6280,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
@@ -6300,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
@@ -6380,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
@@ -6889,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,
@@ -6901,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:
@@ -7022,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:
@@ -7055,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(
@@ -7071,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,
@@ -7099,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,
@@ -7110,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,
                 )
@@ -7152,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(
@@ -7182,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
@@ -7198,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,
@@ -7237,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,
                 )
@@ -7275,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
@@ -7296,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,
@@ -7310,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
@@ -7350,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
@@ -7384,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
@@ -7410,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,
@@ -7424,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
@@ -7448,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)
 
@@ -7487,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,
@@ -7502,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}"
@@ -8316,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]:
@@ -8542,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: