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

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

@@ -440,7 +440,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 +458,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

agno/tools/notion.py

@@ -0,0 +1,201 @@
+import json
+import os
+from typing import Any, List, Optional
+
+from agno.tools import Toolkit
+from agno.utils.log import log_debug, logger
+
+try:
+    from notion_client import Client
+except ImportError:
+    raise ImportError("`notion-client` not installed. Please install using `pip install notion-client`")
+
+
+class NotionTools(Toolkit):
+    """
+    Notion toolkit for creating and managing Notion pages.
+
+    Args:
+        api_key (Optional[str]): Notion API key (integration token). If not provided, uses NOTION_API_KEY env var.
+        database_id (Optional[str]): The ID of the database to work with. If not provided, uses NOTION_DATABASE_ID env var.
+        enable_create_page (bool): Enable creating pages. Default is True.
+        enable_update_page (bool): Enable updating pages. Default is True.
+        enable_search_pages (bool): Enable searching pages. Default is True.
+        all (bool): Enable all tools. Overrides individual flags when True. Default is False.
+    """
+
+    def __init__(
+        self,
+        api_key: Optional[str] = None,
+        database_id: Optional[str] = None,
+        enable_create_page: bool = True,
+        enable_update_page: bool = True,
+        enable_search_pages: bool = True,
+        all: bool = False,
+        **kwargs,
+    ):
+        self.api_key = api_key or os.getenv("NOTION_API_KEY")
+        self.database_id = database_id or os.getenv("NOTION_DATABASE_ID")
+
+        if not self.api_key:
+            raise ValueError(
+                "Notion API key is required. Either pass api_key parameter or set NOTION_API_KEY environment variable."
+            )
+        if not self.database_id:
+            raise ValueError(
+                "Notion database ID is required. Either pass database_id parameter or set NOTION_DATABASE_ID environment variable."
+            )
+
+        self.client = Client(auth=self.api_key)
+
+        tools: List[Any] = []
+        if all or enable_create_page:
+            tools.append(self.create_page)
+        if all or enable_update_page:
+            tools.append(self.update_page)
+        if all or enable_search_pages:
+            tools.append(self.search_pages)
+
+        super().__init__(name="notion_tools", tools=tools, **kwargs)
+
+    def create_page(self, title: str, tag: str, content: str) -> str:
+        """Create a new page in the Notion database with a title, tag, and content.
+
+        Args:
+            title (str): The title of the page
+            tag (str): The tag/category for the page (e.g., travel, tech, general-blogs, fashion, documents)
+            content (str): The content to add to the page
+
+        Returns:
+            str: JSON string with page creation details
+        """
+        try:
+            log_debug(f"Creating Notion page with title: {title}, tag: {tag}")
+
+            # Create the page in the database
+            new_page = self.client.pages.create(
+                parent={"database_id": self.database_id},
+                properties={"Name": {"title": [{"text": {"content": title}}]}, "Tag": {"select": {"name": tag}}},
+                children=[
+                    {
+                        "object": "block",
+                        "type": "paragraph",
+                        "paragraph": {"rich_text": [{"type": "text", "text": {"content": content}}]},
+                    }
+                ],
+            )
+
+            result = {"success": True, "page_id": new_page["id"], "url": new_page["url"], "title": title, "tag": tag}
+            return json.dumps(result, indent=2)
+
+        except Exception as e:
+            logger.exception(e)
+            return json.dumps({"success": False, "error": str(e)})
+
+    def update_page(self, page_id: str, content: str) -> str:
+        """Add content to an existing Notion page.
+
+        Args:
+            page_id (str): The ID of the page to update
+            content (str): The content to append to the page
+
+        Returns:
+            str: JSON string with update status
+        """
+        try:
+            log_debug(f"Updating Notion page: {page_id}")
+
+            # Append content to the page
+            self.client.blocks.children.append(
+                block_id=page_id,
+                children=[
+                    {
+                        "object": "block",
+                        "type": "paragraph",
+                        "paragraph": {"rich_text": [{"type": "text", "text": {"content": content}}]},
+                    }
+                ],
+            )
+
+            result = {"success": True, "page_id": page_id, "message": "Content added successfully"}
+            return json.dumps(result, indent=2)
+
+        except Exception as e:
+            logger.exception(e)
+            return json.dumps({"success": False, "error": str(e)})
+
+    def search_pages(self, tag: str) -> str:
+        """Search for pages in the database by tag.
+
+        Args:
+            tag (str): The tag to search for
+
+        Returns:
+            str: JSON string with list of matching pages
+        """
+        try:
+            log_debug(f"Searching for pages with tag: {tag}")
+
+            import httpx
+
+            headers = {
+                "Authorization": f"Bearer {self.api_key}",
+                "Notion-Version": "2022-06-28",
+                "Content-Type": "application/json",
+            }
+
+            payload = {"filter": {"property": "Tag", "select": {"equals": tag}}}
+
+            # The SDK client does not support the query method
+            response = httpx.post(
+                f"https://api.notion.com/v1/databases/{self.database_id}/query",
+                headers=headers,
+                json=payload,
+                timeout=30.0,
+            )
+
+            if response.status_code != 200:
+                return json.dumps(
+                    {
+                        "success": False,
+                        "error": f"API request failed with status {response.status_code}",
+                        "message": response.text,
+                    }
+                )
+
+            data = response.json()
+            pages = []
+
+            for page in data.get("results", []):
+                try:
+                    page_title = "Untitled"
+                    if page.get("properties", {}).get("Name", {}).get("title"):
+                        page_title = page["properties"]["Name"]["title"][0]["text"]["content"]
+
+                    page_tag = None
+                    if page.get("properties", {}).get("Tag", {}).get("select"):
+                        page_tag = page["properties"]["Tag"]["select"]["name"]
+
+                    page_info = {
+                        "page_id": page["id"],
+                        "title": page_title,
+                        "tag": page_tag,
+                        "url": page.get("url", ""),
+                    }
+                    pages.append(page_info)
+                except Exception as page_error:
+                    log_debug(f"Error parsing page: {page_error}")
+                    continue
+
+            result = {"success": True, "count": len(pages), "pages": pages}
+            return json.dumps(result, indent=2)
+
+        except Exception as e:
+            logger.exception(e)
+            return json.dumps(
+                {
+                    "success": False,
+                    "error": str(e),
+                    "message": "Failed to search pages. Make sure the database is shared with the integration and has a 'Tag' property.",
+                }
+            )

agno/utils/events.py

@@ -106,6 +106,7 @@ def create_team_run_completed_event(from_run_response: TeamRunOutput) -> TeamRun
         member_responses=from_run_response.member_responses,  # type: ignore
         metadata=from_run_response.metadata,  # type: ignore
         metrics=from_run_response.metrics,  # type: ignore
+        session_state=from_run_response.session_state,  # type: ignore
     )
 
 
@@ -130,6 +131,7 @@ def create_run_completed_event(from_run_response: RunOutput) -> RunCompletedEven
         reasoning_messages=from_run_response.reasoning_messages,  # type: ignore
         metadata=from_run_response.metadata,  # type: ignore
         metrics=from_run_response.metrics,  # type: ignore
+        session_state=from_run_response.session_state,  # type: ignore
     )