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

agno/tools/exa.py

@@ -27,14 +27,14 @@ class ExaTools(Toolkit):
         all (bool): Enable all tools. Overrides individual flags when True. Default is False.
         text (bool): Retrieve text content from results. Default is True.
         text_length_limit (int): Max length of text content per result. Default is 1000.
-        highlights (bool): Include highlighted snippets. Default is True.
+        highlights (bool): Include highlighted snippets. Deprecated since it was removed in the Exa API. It will be removed from Agno in a future release.
         api_key (Optional[str]): Exa API key. Retrieved from `EXA_API_KEY` env variable if not provided.
         num_results (Optional[int]): Default number of search results. Overrides individual searches if set.
         start_crawl_date (Optional[str]): Include results crawled on/after this date (`YYYY-MM-DD`).
         end_crawl_date (Optional[str]): Include results crawled on/before this date (`YYYY-MM-DD`).
         start_published_date (Optional[str]): Include results published on/after this date (`YYYY-MM-DD`).
         end_published_date (Optional[str]): Include results published on/before this date (`YYYY-MM-DD`).
-        use_autoprompt (Optional[bool]): Enable autoprompt features in queries.
+        use_autoprompt (Optional[bool]): Enable autoprompt features in queries. Deprecated since it was removed in the Exa API. It will be removed from Agno in a future release.
         type (Optional[str]): Specify content type (e.g., article, blog, video).
         category (Optional[str]): Filter results by category. Options are "company", "research paper", "news", "pdf", "github", "tweet", "personal site", "linkedin profile", "financial report".
         include_domains (Optional[List[str]]): Restrict results to these domains.
@@ -54,7 +54,7 @@ class ExaTools(Toolkit):
         all: bool = False,
         text: bool = True,
         text_length_limit: int = 1000,
-        highlights: bool = True,
+        highlights: Optional[bool] = None,  # Deprecated
         summary: bool = False,
         api_key: Optional[str] = None,
         num_results: Optional[int] = None,
@@ -84,7 +84,24 @@ class ExaTools(Toolkit):
 
         self.text: bool = text
         self.text_length_limit: int = text_length_limit
-        self.highlights: bool = highlights
+
+        if highlights:
+            import warnings
+
+            warnings.warn(
+                "The 'highlights' parameter is deprecated since it was removed in the Exa API. It will be removed from Agno in a future release.",
+                DeprecationWarning,
+                stacklevel=2,
+            )
+        if use_autoprompt:
+            import warnings
+
+            warnings.warn(
+                "The 'use_autoprompt' parameter is deprecated since it was removed in the Exa API. It will be removed from Agno in a future release.",
+                DeprecationWarning,
+                stacklevel=2,
+            )
+
         self.summary: bool = summary
         self.num_results: Optional[int] = num_results
         self.livecrawl: str = livecrawl
@@ -92,7 +109,6 @@ class ExaTools(Toolkit):
         self.end_crawl_date: Optional[str] = end_crawl_date
         self.start_published_date: Optional[str] = start_published_date
         self.end_published_date: Optional[str] = end_published_date
-        self.use_autoprompt: Optional[bool] = use_autoprompt
         self.type: Optional[str] = type
         self.category: Optional[str] = category
         self.include_domains: Optional[List[str]] = include_domains
@@ -140,13 +156,6 @@ class ExaTools(Toolkit):
                 if self.text_length_limit:
                     _text = _text[: self.text_length_limit]
                 result_dict["text"] = _text
-            if self.highlights:
-                try:
-                    if result.highlights:  # type: ignore
-                        result_dict["highlights"] = result.highlights  # type: ignore
-                except Exception as e:
-                    log_debug(f"Failed to get highlights {e}")
-                    result_dict["highlights"] = f"Failed to get highlights {e}"
             exa_results_parsed.append(result_dict)
         return json.dumps(exa_results_parsed, indent=4, ensure_ascii=False)
 
@@ -168,14 +177,12 @@ class ExaTools(Toolkit):
                 log_info(f"Searching exa for: {query}")
             search_kwargs: Dict[str, Any] = {
                 "text": self.text,
-                "highlights": self.highlights,
                 "summary": self.summary,
                 "num_results": self.num_results or num_results,
                 "start_crawl_date": self.start_crawl_date,
                 "end_crawl_date": self.end_crawl_date,
                 "start_published_date": self.start_published_date,
                 "end_published_date": self.end_published_date,
-                "use_autoprompt": self.use_autoprompt,
                 "type": self.type,
                 "category": self.category or category,  # Prefer a user-set category
                 "include_domains": self.include_domains,
@@ -212,7 +219,6 @@ class ExaTools(Toolkit):
 
         query_kwargs: Dict[str, Any] = {
             "text": self.text,
-            "highlights": self.highlights,
             "summary": self.summary,
         }
 
@@ -249,7 +255,6 @@ class ExaTools(Toolkit):
 
         query_kwargs: Dict[str, Any] = {
             "text": self.text,
-            "highlights": self.highlights,
             "summary": self.summary,
             "include_domains": self.include_domains,
             "exclude_domains": self.exclude_domains,

agno/tools/file.py

@@ -1,9 +1,9 @@
 import json
 from pathlib import Path
-from typing import Any, List, Optional
+from typing import Any, List, Optional, Tuple
 
 from agno.tools import Toolkit
-from agno.utils.log import log_debug, log_error, log_info
+from agno.utils.log import log_debug, log_error
 
 
 class FileTools(Toolkit):
@@ -12,14 +12,26 @@ class FileTools(Toolkit):
         base_dir: Optional[Path] = None,
         enable_save_file: bool = True,
         enable_read_file: bool = True,
+        enable_delete_file: bool = False,
         enable_list_files: bool = True,
         enable_search_files: bool = True,
+        enable_read_file_chunk: bool = True,
+        enable_replace_file_chunk: bool = True,
+        expose_base_directory: bool = False,
+        max_file_length: int = 10000000,
+        max_file_lines: int = 100000,
+        line_separator: str = "\n",
         all: bool = False,
         **kwargs,
     ):
         self.base_dir: Path = base_dir or Path.cwd()
+        self.base_dir = self.base_dir.resolve()
 
         tools: List[Any] = []
+        self.max_file_length = max_file_length
+        self.max_file_lines = max_file_lines
+        self.line_separator = line_separator
+        self.expose_base_directory = expose_base_directory
         if all or enable_save_file:
             tools.append(self.save_file)
         if all or enable_read_file:
@@ -28,10 +40,16 @@ class FileTools(Toolkit):
             tools.append(self.list_files)
         if all or enable_search_files:
             tools.append(self.search_files)
+        if all or enable_delete_file:
+            tools.append(self.delete_file)
+        if all or enable_read_file_chunk:
+            tools.append(self.read_file_chunk)
+        if all or enable_replace_file_chunk:
+            tools.append(self.replace_file_chunk)
 
         super().__init__(name="file_tools", tools=tools, **kwargs)
 
-    def save_file(self, contents: str, file_name: str, overwrite: bool = True) -> str:
+    def save_file(self, contents: str, file_name: str, overwrite: bool = True, encoding: str = "utf-8") -> str:
         """Saves the contents to a file called `file_name` and returns the file name if successful.
 
         :param contents: The contents to save.
@@ -40,44 +58,146 @@ class FileTools(Toolkit):
         :return: The file name if successful, otherwise returns an error message.
         """
         try:
-            file_path = self.base_dir.joinpath(file_name)
+            safe, file_path = self.check_escape(file_name)
+            if not (safe):
+                log_error(f"Attempted to save file: {file_name}")
+                return "Error saving file"
             log_debug(f"Saving contents to {file_path}")
             if not file_path.parent.exists():
                 file_path.parent.mkdir(parents=True, exist_ok=True)
             if file_path.exists() and not overwrite:
                 return f"File {file_name} already exists"
-            file_path.write_text(contents)
-            log_info(f"Saved: {file_path}")
+            file_path.write_text(contents, encoding=encoding)
+            log_debug(f"Saved: {file_path}")
             return str(file_name)
         except Exception as e:
             log_error(f"Error saving to file: {e}")
             return f"Error saving to file: {e}"
 
-    def read_file(self, file_name: str) -> str:
+    def read_file_chunk(self, file_name: str, start_line: int, end_line: int, encoding: str = "utf-8") -> str:
+        """Reads the contents of the file `file_name` and returns lines from start_line to end_line.
+
+        :param file_name: The name of the file to read.
+        :param start_line: Number of first line in the returned chunk
+        :param end_line: Number of the last line in the returned chunk
+        :param encoding: Encoding to use, default - utf-8
+
+        :return: The contents of the selected chunk
+        """
+        try:
+            log_debug(f"Reading file: {file_name}")
+            safe, file_path = self.check_escape(file_name)
+            if not (safe):
+                log_error(f"Attempted to read file: {file_name}")
+                return "Error reading file"
+            contents = file_path.read_text(encoding=encoding)
+            lines = contents.split(self.line_separator)
+            return self.line_separator.join(lines[start_line : end_line + 1])
+        except Exception as e:
+            log_error(f"Error reading file: {e}")
+            return f"Error reading file: {e}"
+
+    def replace_file_chunk(
+        self, file_name: str, start_line: int, end_line: int, chunk: str, encoding: str = "utf-8"
+    ) -> str:
+        """Reads the contents of the file, replaces lines
+        between start_line and end_line with chunk and writes the file
+
+        :param file_name: The name of the file to process.
+        :param start_line: Number of first line in the replaced chunk
+        :param end_line: Number of the last line in the replaced chunk
+        :param chunk: String to be inserted instead of lines from start_line to end_line. Can have multiple lines.
+        :param encoding: Encoding to use, default - utf-8
+
+        :return: file name if successfull, error message otherwise
+        """
+        try:
+            log_debug(f"Patching file: {file_name}")
+            safe, file_path = self.check_escape(file_name)
+            if not (safe):
+                log_error(f"Attempted to read file: {file_name}")
+                return "Error reading file"
+            contents = file_path.read_text(encoding=encoding)
+            lines = contents.split(self.line_separator)
+            start = lines[0:start_line]
+            end = lines[end_line + 1 :]
+            return self.save_file(
+                file_name=file_name, contents=self.line_separator.join(start + [chunk] + end), encoding=encoding
+            )
+        except Exception as e:
+            log_error(f"Error patching file: {e}")
+            return f"Error patching file: {e}"
+
+    def read_file(self, file_name: str, encoding: str = "utf-8") -> str:
         """Reads the contents of the file `file_name` and returns the contents if successful.
 
         :param file_name: The name of the file to read.
+        :param encoding: Encoding to use, default - utf-8
         :return: The contents of the file if successful, otherwise returns an error message.
         """
         try:
-            log_info(f"Reading file: {file_name}")
-            file_path = self.base_dir.joinpath(file_name)
-            contents = file_path.read_text(encoding="utf-8")
+            log_debug(f"Reading file: {file_name}")
+            safe, file_path = self.check_escape(file_name)
+            if not (safe):
+                log_error(f"Attempted to read file: {file_name}")
+                return "Error reading file"
+            contents = file_path.read_text(encoding=encoding)
+            if len(contents) > self.max_file_length:
+                return "Error reading file: file too long. Use read_file_chunk instead"
+            if len(contents.split(self.line_separator)) > self.max_file_lines:
+                return "Error reading file: file too long. Use read_file_chunk instead"
+
             return str(contents)
         except Exception as e:
             log_error(f"Error reading file: {e}")
             return f"Error reading file: {e}"
 
-    def list_files(self) -> str:
-        """Returns a list of files in the base directory
+    def delete_file(self, file_name: str) -> str:
+        """Deletes a file
+        :param file_name: Name of the file to delete
+
+        :return: Empty string, if operation succeeded, otherwise returns an error message
+        """
+        safe, path = self.check_escape(file_name)
+        try:
+            if safe:
+                if path.is_dir():
+                    path.rmdir()
+                    return ""
+                path.unlink()
+                return ""
+            else:
+                log_error(f"Attempt to delete file outside {self.base_dir}: {file_name}")
+                return "Incorrect file_name"
+        except Exception as e:
+            log_error(f"Error removing {file_name}: {e}")
+            return f"Error removing file: {e}"
+
+    def check_escape(self, relative_path: str) -> Tuple[bool, Path]:
+        d = self.base_dir.joinpath(Path(relative_path)).resolve()
+        if self.base_dir == d:
+            return True, d
+        try:
+            d.relative_to(self.base_dir)
+        except ValueError:
+            log_error("Attempted to escape base_dir")
+            return False, self.base_dir
+        return True, d
+
+    def list_files(self, **kwargs) -> str:
+        """Returns a list of files in directory
+        :param directory: (Optional) name of directory to list.
 
         :return: The contents of the file if successful, otherwise returns an error message.
         """
+        directory = kwargs.get("directory", ".")
         try:
-            log_info(f"Reading files in : {self.base_dir}")
-            return json.dumps(
-                [str(file_path.relative_to(self.base_dir)) for file_path in self.base_dir.iterdir()], indent=4
-            )
+            log_debug(f"Reading files in : {self.base_dir}/{directory}")
+            safe, d = self.check_escape(directory)
+            if safe:
+                return json.dumps([str(file_path.relative_to(self.base_dir)) for file_path in d.iterdir()], indent=4)
+            else:
+                return "{}"
         except Exception as e:
             log_error(f"Error reading files: {e}")
             return f"Error reading files: {e}"
@@ -94,15 +214,23 @@ class FileTools(Toolkit):
 
             log_debug(f"Searching files in {self.base_dir} with pattern {pattern}")
             matching_files = list(self.base_dir.glob(pattern))
-
-            file_paths = [str(file_path.relative_to(self.base_dir)) for file_path in matching_files]
-
-            result = {
-                "pattern": pattern,
-                "base_directory": str(self.base_dir),
-                "matches_found": len(file_paths),
-                "files": file_paths,
-            }
+            result = None
+            if self.expose_base_directory:
+                file_paths = [str(file_path) for file_path in matching_files]
+                result = {
+                    "pattern": pattern,
+                    "matches_found": len(file_paths),
+                    "base_directory": str(self.base_dir),
+                    "files": file_paths,
+                }
+            else:
+                file_paths = [str(file_path.relative_to(self.base_dir)) for file_path in matching_files]
+
+                result = {
+                    "pattern": pattern,
+                    "matches_found": len(file_paths),
+                    "files": file_paths,
+                }
             log_debug(f"Found {len(file_paths)} files matching pattern {pattern}")
             return json.dumps(result, indent=2)
 

agno/tools/function.py

@@ -9,6 +9,7 @@ from pydantic import BaseModel, Field, validate_call
 
 from agno.exceptions import AgentRunException
 from agno.media import Audio, File, Image, Video
+from agno.run import RunContext
 from agno.utils.log import log_debug, log_error, log_exception, log_warning
 
 T = TypeVar("T")
@@ -122,6 +123,8 @@ class Function(BaseModel):
     _agent: Optional[Any] = None
     # The team that the function is associated with
     _team: Optional[Any] = None
+    # The run context that the function is associated with
+    _run_context: Optional[RunContext] = None
     # The session state that the function is associated with
     _session_state: Optional[Dict[str, Any]] = None
     # The dependencies that the function is associated with
@@ -196,8 +199,13 @@ class Function(BaseModel):
                 del type_hints["agent"]
             if "team" in sig.parameters and "team" in type_hints:
                 del type_hints["team"]
+            if "run_context" in sig.parameters and "run_context" in type_hints:
+                del type_hints["run_context"]
             if "session_state" in sig.parameters and "session_state" in type_hints:
                 del type_hints["session_state"]
+            if "dependencies" in sig.parameters and "dependencies" in type_hints:
+                del type_hints["dependencies"]
+
             # Remove media parameters from type hints as they are injected automatically
             if "images" in sig.parameters and "images" in type_hints:
                 del type_hints["images"]
@@ -207,8 +215,6 @@ class Function(BaseModel):
                 del type_hints["audios"]
             if "files" in sig.parameters and "files" in type_hints:
                 del type_hints["files"]
-            if "dependencies" in sig.parameters and "dependencies" in type_hints:
-                del type_hints["dependencies"]
             # log_info(f"Type hints for {function_name}: {type_hints}")
 
             # Filter out return type and only process parameters
@@ -217,7 +223,18 @@ class Function(BaseModel):
                 for name in sig.parameters
                 if name != "return"
                 and name
-                not in ["agent", "team", "session_state", "self", "images", "videos", "audios", "files", "dependencies"]
+                not in [
+                    "agent",
+                    "team",
+                    "run_context",
+                    "session_state",
+                    "dependencies",
+                    "self",
+                    "images",
+                    "videos",
+                    "audios",
+                    "files",
+                ]
             }
 
             # Parse docstring for parameters
@@ -250,13 +267,14 @@ class Function(BaseModel):
                     not in [
                         "agent",
                         "team",
+                        "run_context",
                         "session_state",
+                        "dependencies",
                         "self",
                         "images",
                         "videos",
                         "audios",
                         "files",
-                        "dependencies",
                     ]
                 ]
             else:
@@ -269,13 +287,14 @@ class Function(BaseModel):
                     not in [
                         "agent",
                         "team",
+                        "run_context",
                         "session_state",
+                        "dependencies",
                         "self",
                         "images",
                         "videos",
                         "audios",
                         "files",
-                        "dependencies",
                     ]
                 ]
 
@@ -325,8 +344,12 @@ class Function(BaseModel):
                 del type_hints["agent"]
             if "team" in sig.parameters and "team" in type_hints:
                 del type_hints["team"]
+            if "run_context" in sig.parameters and "run_context" in type_hints:
+                del type_hints["run_context"]
             if "session_state" in sig.parameters and "session_state" in type_hints:
                 del type_hints["session_state"]
+            if "dependencies" in sig.parameters and "dependencies" in type_hints:
+                del type_hints["dependencies"]
             if "images" in sig.parameters and "images" in type_hints:
                 del type_hints["images"]
             if "videos" in sig.parameters and "videos" in type_hints:
@@ -335,8 +358,6 @@ class Function(BaseModel):
                 del type_hints["audios"]
             if "files" in sig.parameters and "files" in type_hints:
                 del type_hints["files"]
-            if "dependencies" in sig.parameters and "dependencies" in type_hints:
-                del type_hints["dependencies"]
             # log_info(f"Type hints for {self.name}: {type_hints}")
 
             # Filter out return type and only process parameters
@@ -344,13 +365,14 @@ class Function(BaseModel):
                 "return",
                 "agent",
                 "team",
+                "run_context",
                 "session_state",
+                "dependencies",
                 "self",
                 "images",
                 "videos",
                 "audios",
                 "files",
-                "dependencies",
             ]
             if self.requires_user_input and self.user_input_fields:
                 if len(self.user_input_fields) == 0:
@@ -440,7 +462,7 @@ class Function(BaseModel):
     @staticmethod
     def _wrap_callable(func: Callable) -> Callable:
         """Wrap a callable with Pydantic's validate_call decorator, if relevant"""
-        from inspect import isasyncgenfunction, iscoroutinefunction
+        from inspect import isasyncgenfunction, iscoroutinefunction, signature
 
         pydantic_version = Version(version("pydantic"))
 
@@ -458,6 +480,10 @@ class Function(BaseModel):
         # Don't wrap callables that are already wrapped with validate_call
         elif getattr(func, "_wrapped_for_validation", False):
             return func
+        # Don't wrap functions with session_state parameter
+        # session_state needs to be passed by reference, not copied by pydantic's validation
+        elif "session_state" in signature(func).parameters:
+            return func
         # Wrap the callable with validate_call
         else:
             wrapped = validate_call(func, config=dict(arbitrary_types_allowed=True))  # type: ignore
@@ -508,7 +534,18 @@ class Function(BaseModel):
             name
             for name in self.parameters["properties"]
             if name
-            not in ["agent", "team", "session_state", "images", "videos", "audios", "files", "self", "dependencies"]
+            not in [
+                "agent",
+                "team",
+                "run_context",
+                "session_state",
+                "dependencies",
+                "images",
+                "videos",
+                "audios",
+                "files",
+                "self",
+            ]
         ]
 
     def _get_cache_key(self, entrypoint_args: Dict[str, Any], call_args: Optional[Dict[str, Any]] = None) -> str:
@@ -522,8 +559,12 @@ class Function(BaseModel):
             del copy_entrypoint_args["agent"]
         if "team" in copy_entrypoint_args:
             del copy_entrypoint_args["team"]
+        if "run_context" in copy_entrypoint_args:
+            del copy_entrypoint_args["run_context"]
         if "session_state" in copy_entrypoint_args:
             del copy_entrypoint_args["session_state"]
+        if "dependencies" in copy_entrypoint_args:
+            del copy_entrypoint_args["dependencies"]
         if "images" in copy_entrypoint_args:
             del copy_entrypoint_args["images"]
         if "videos" in copy_entrypoint_args:
@@ -532,8 +573,6 @@ class Function(BaseModel):
             del copy_entrypoint_args["audios"]
         if "files" in copy_entrypoint_args:
             del copy_entrypoint_args["files"]
-        if "dependencies" in copy_entrypoint_args:
-            del copy_entrypoint_args["dependencies"]
         # Use json.dumps with sort_keys=True to ensure consistent ordering regardless of dict key order
         args_str = json.dumps(copy_entrypoint_args, sort_keys=True, default=str)
 
@@ -659,8 +698,14 @@ class FunctionCall(BaseModel):
                 if "team" in signature(self.function.pre_hook).parameters:
                     pre_hook_args["team"] = self.function._team
                 # Check if the pre-hook has an session_state argument
+                if "run_context" in signature(self.function.pre_hook).parameters:
+                    pre_hook_args["run_context"] = self.function._run_context
+                # Check if the pre-hook has an session_state argument
                 if "session_state" in signature(self.function.pre_hook).parameters:
                     pre_hook_args["session_state"] = self.function._session_state
+                # Check if the pre-hook has an dependencies argument
+                if "dependencies" in signature(self.function.pre_hook).parameters:
+                    pre_hook_args["dependencies"] = self.function._dependencies
                 # Check if the pre-hook has an fc argument
                 if "fc" in signature(self.function.pre_hook).parameters:
                     pre_hook_args["fc"] = self
@@ -687,8 +732,14 @@ class FunctionCall(BaseModel):
                 if "team" in signature(self.function.post_hook).parameters:
                     post_hook_args["team"] = self.function._team
                 # Check if the post-hook has an session_state argument
+                if "run_context" in signature(self.function.post_hook).parameters:
+                    post_hook_args["run_context"] = self.function._run_context
+                # Check if the post-hook has an session_state argument
                 if "session_state" in signature(self.function.post_hook).parameters:
                     post_hook_args["session_state"] = self.function._session_state
+                # Check if the post-hook has an dependencies argument
+                if "dependencies" in signature(self.function.post_hook).parameters:
+                    post_hook_args["dependencies"] = self.function._dependencies
                 # Check if the post-hook has an fc argument
                 if "fc" in signature(self.function.post_hook).parameters:
                     post_hook_args["fc"] = self
@@ -712,6 +763,9 @@ class FunctionCall(BaseModel):
         # Check if the entrypoint has an team argument
         if "team" in signature(self.function.entrypoint).parameters:  # type: ignore
             entrypoint_args["team"] = self.function._team
+        # Check if the entrypoint has an run_context argument
+        if "run_context" in signature(self.function.entrypoint).parameters:  # type: ignore
+            entrypoint_args["run_context"] = self.function._run_context
         # Check if the entrypoint has an session_state argument
         if "session_state" in signature(self.function.entrypoint).parameters:  # type: ignore
             entrypoint_args["session_state"] = self.function._session_state
@@ -744,13 +798,15 @@ class FunctionCall(BaseModel):
         # Check if the hook has an team argument
         if "team" in signature(hook).parameters:
             hook_args["team"] = self.function._team
+        # Check if the hook has an run_context argument
+        if "run_context" in signature(hook).parameters:
+            hook_args["run_context"] = self.function._run_context
         # Check if the hook has an session_state argument
         if "session_state" in signature(hook).parameters:
             hook_args["session_state"] = self.function._session_state
         # Check if the hook has an dependencies argument
         if "dependencies" in signature(hook).parameters:
             hook_args["dependencies"] = self.function._dependencies
-
         if "name" in signature(hook).parameters:
             hook_args["name"] = name
         if "function_name" in signature(hook).parameters:
@@ -853,8 +909,16 @@ class FunctionCall(BaseModel):
                 result = self.function.entrypoint(**entrypoint_args, **self.arguments)  # type: ignore
 
             updated_session_state = None
-            if entrypoint_args.get("session_state") is not None:
-                updated_session_state = entrypoint_args.get("session_state")
+            if entrypoint_args.get("run_context") is not None:
+                run_context = entrypoint_args.get("run_context")
+                updated_session_state = (
+                    run_context.session_state
+                    if run_context is not None and run_context.session_state is not None
+                    else None
+                )
+            else:
+                if self.function._session_state is not None:
+                    updated_session_state = self.function._session_state
 
             # Handle generator case
             if isgenerator(result):
@@ -902,9 +966,15 @@ class FunctionCall(BaseModel):
                 # Check if the pre-hook has an team argument
                 if "team" in signature(self.function.pre_hook).parameters:
                     pre_hook_args["team"] = self.function._team
+                # Check if the pre-hook has an run_context argument
+                if "run_context" in signature(self.function.pre_hook).parameters:
+                    pre_hook_args["run_context"] = self.function._run_context
                 # Check if the pre-hook has an session_state argument
                 if "session_state" in signature(self.function.pre_hook).parameters:
                     pre_hook_args["session_state"] = self.function._session_state
+                # Check if the pre-hook has an dependencies argument
+                if "dependencies" in signature(self.function.pre_hook).parameters:
+                    pre_hook_args["dependencies"] = self.function._dependencies
                 # Check if the pre-hook has an fc argument
                 if "fc" in signature(self.function.pre_hook).parameters:
                     pre_hook_args["fc"] = self
@@ -931,9 +1001,15 @@ class FunctionCall(BaseModel):
                 # Check if the post-hook has an team argument
                 if "team" in signature(self.function.post_hook).parameters:
                     post_hook_args["team"] = self.function._team
+                # Check if the post-hook has an run_context argument
+                if "run_context" in signature(self.function.post_hook).parameters:
+                    post_hook_args["run_context"] = self.function._run_context
                 # Check if the post-hook has an session_state argument
                 if "session_state" in signature(self.function.post_hook).parameters:
                     post_hook_args["session_state"] = self.function._session_state
+                # Check if the post-hook has an dependencies argument
+                if "dependencies" in signature(self.function.post_hook).parameters:
+                    post_hook_args["dependencies"] = self.function._dependencies
 
                 # Check if the post-hook has an fc argument
                 if "fc" in signature(self.function.post_hook).parameters:
@@ -1067,8 +1143,13 @@ class FunctionCall(BaseModel):
                 self.function._save_to_cache(cache_file, self.result)
 
             updated_session_state = None
-            if entrypoint_args.get("session_state") is not None:
-                updated_session_state = entrypoint_args.get("session_state")
+            if entrypoint_args.get("run_context") is not None:
+                run_context = entrypoint_args.get("run_context")
+                updated_session_state = (
+                    run_context.session_state
+                    if run_context is not None and run_context.session_state is not None
+                    else None
+                )
 
             execution_result = FunctionExecutionResult(
                 status="success", result=self.result, updated_session_state=updated_session_state