agno 2.1.2__py3-none-any.whl → 2.3.13__py3-none-any.whl

agno/tools/dalle.py

@@ -1,10 +1,8 @@
 from os import getenv
-from typing import Any, List, Literal, Optional, Union
+from typing import Any, List, Literal, Optional
 from uuid import uuid4
 
-from agno.agent import Agent
 from agno.media import Image
-from agno.team.team import Team
 from agno.tools import Toolkit
 from agno.tools.function import ToolResult
 from agno.utils.log import log_debug, logger
@@ -64,7 +62,7 @@ class DalleTools(Toolkit):
         # - Add support for saving images
         # - Add support for editing images
 
-    def create_image(self, agent: Union[Agent, Team], prompt: str) -> ToolResult:
+    def create_image(self, prompt: str) -> ToolResult:
         """Use this function to generate an image for a prompt.
 
         Args:

agno/tools/eleven_labs.py

@@ -1,4 +1,3 @@
-from base64 import b64encode
 from io import BytesIO
 from os import getenv, path
 from pathlib import Path
@@ -10,7 +9,7 @@ from agno.media import Audio
 from agno.team.team import Team
 from agno.tools import Toolkit
 from agno.tools.function import ToolResult
-from agno.utils.log import logger
+from agno.utils.log import log_error, log_info
 
 try:
     from elevenlabs import ElevenLabs  # type: ignore
@@ -48,7 +47,7 @@ class ElevenLabsTools(Toolkit):
     ):
         self.api_key = api_key or getenv("ELEVEN_LABS_API_KEY")
         if not self.api_key:
-            logger.error("ELEVEN_LABS_API_KEY not set. Please set the ELEVEN_LABS_API_KEY environment variable.")
+            log_error("ELEVEN_LABS_API_KEY not set. Please set the ELEVEN_LABS_API_KEY environment variable.")
 
         self.target_directory = target_directory
         self.voice_id = voice_id
@@ -73,7 +72,7 @@ class ElevenLabsTools(Toolkit):
 
     def get_voices(self) -> str:
         """
-        Use this function to get all the voices available.
+        Get all the voices available.
 
         Returns:
             result (list): A list of voices that have an ID, name and description.
@@ -94,20 +93,19 @@ class ElevenLabsTools(Toolkit):
             return str(response)
 
         except Exception as e:
-            logger.error(f"Failed to fetch voices: {e}")
+            log_error(f"Failed to fetch voices: {e}")
             return f"Error: {e}"
 
-    def _process_audio(self, audio_generator: Iterator[bytes]) -> str:
-        # Step 1: Write audio data to BytesIO
+    def _process_audio(self, audio_generator: Iterator[bytes]) -> bytes:
         audio_bytes = BytesIO()
         for chunk in audio_generator:
             audio_bytes.write(chunk)
-        audio_bytes.seek(0)  # Rewind the stream
 
-        # Step 2: Encode as Base64
-        base64_audio = b64encode(audio_bytes.read()).decode("utf-8")
+        # Read bytes
+        audio_bytes.seek(0)
+        audio_data = audio_bytes.read()
 
-        # Step 3: Optionally save to disk if target_directory exists
+        # Save to disk if target_directory exists
         if self.target_directory:
             # Determine file extension based on output format
             if self.output_format.startswith("mp3"):
@@ -122,19 +120,19 @@ class ElevenLabsTools(Toolkit):
             output_filename = f"{uuid4()}.{extension}"
             output_path = path.join(self.target_directory, output_filename)
 
-            # Write from BytesIO to disk
-            audio_bytes.seek(0)  # Reset the BytesIO stream again
             with open(output_path, "wb") as f:
-                f.write(audio_bytes.read())
+                f.write(audio_data)
 
-        return base64_audio
+            log_info(f"Audio saved to: {output_path}")
+
+        return audio_data
 
     def generate_sound_effect(self, prompt: str, duration_seconds: Optional[float] = None) -> ToolResult:
         """
-        Use this function to generate sound effect audio from a text prompt.
+        Generate a sound effect from a text description.
 
         Args:
-            prompt (str): Text to generate audio from.
+            prompt (str): Description of the sound effect
             duration_seconds (Optional[float]): Duration in seconds to generate audio from. Has to be between 0.5 and 22.
         Returns:
             ToolResult: A ToolResult containing the generated audio or error message.
@@ -144,27 +142,27 @@ class ElevenLabsTools(Toolkit):
                 text=prompt, duration_seconds=duration_seconds
             )
 
-            base64_audio = self._process_audio(audio_generator)
+            audio_data = self._process_audio(audio_generator)
 
             # Create AudioArtifact
             audio_artifact = Audio(
                 id=str(uuid4()),
-                base64_audio=base64_audio,
+                content=audio_data,
                 mime_type="audio/mpeg",
             )
 
             return ToolResult(
-                content="Audio generated successfully",
+                content="Sound effect generated successfully",
                 audios=[audio_artifact],
             )
 
         except Exception as e:
-            logger.error(f"Failed to generate audio: {e}")
+            log_error(f"Failed to generate sound effect: {e}")
             return ToolResult(content=f"Error: {e}")
 
     def text_to_speech(self, agent: Union[Agent, Team], prompt: str) -> ToolResult:
         """
-        Use this function to convert text to speech audio.
+        Convert text to speech.
 
         Args:
             prompt (str): Text to generate audio from.
@@ -179,12 +177,12 @@ class ElevenLabsTools(Toolkit):
                 output_format=self.output_format,
             )
 
-            base64_audio = self._process_audio(audio_generator)
+            audio_data = self._process_audio(audio_generator)
 
             # Create AudioArtifact
             audio_artifact = Audio(
                 id=str(uuid4()),
-                base64_audio=base64_audio,
+                content=audio_data,
                 mime_type="audio/mpeg",
             )
 
@@ -194,5 +192,5 @@ class ElevenLabsTools(Toolkit):
             )
 
         except Exception as e:
-            logger.error(f"Failed to generate audio: {e}")
+            log_error(f"Failed to generate audio: {e}")
             return ToolResult(content=f"Error: {e}")

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,42 +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) 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}"
@@ -92,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) 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/file_generation.py

@@ -108,15 +108,17 @@ class FileGenerationTools(Toolkit):
             # Save file to disk (if output_directory is set)
             file_path = self._save_file_to_disk(json_content, filename)
 
+            content_bytes = json_content.encode("utf-8")
+
             # Create FileArtifact
             file_artifact = File(
                 id=str(uuid4()),
-                content=json_content,
+                content=content_bytes,
                 mime_type="application/json",
                 file_type="json",
                 filename=filename,
-                size=len(json_content.encode("utf-8")),
-                url=f"file://{file_path}" if file_path else None,
+                size=len(content_bytes),
+                filepath=file_path if file_path else None,
             )
 
             log_debug("JSON file generated successfully")
@@ -195,15 +197,17 @@ class FileGenerationTools(Toolkit):
             # Save file to disk (if output_directory is set)
             file_path = self._save_file_to_disk(csv_content, filename)
 
+            content_bytes = csv_content.encode("utf-8")
+
             # Create FileArtifact
             file_artifact = File(
                 id=str(uuid4()),
-                content=csv_content,
+                content=content_bytes,
                 mime_type="text/csv",
                 file_type="csv",
                 filename=filename,
-                size=len(csv_content.encode("utf-8")),
-                url=f"file://{file_path}" if file_path else None,
+                size=len(content_bytes),
+                filepath=file_path if file_path else None,
             )
 
             log_debug("CSV file generated successfully")
@@ -287,7 +291,7 @@ class FileGenerationTools(Toolkit):
                 file_type="pdf",
                 filename=filename,
                 size=len(pdf_content),
-                url=f"file://{file_path}" if file_path else None,
+                filepath=file_path if file_path else None,
             )
 
             log_debug("PDF file generated successfully")
@@ -325,15 +329,17 @@ class FileGenerationTools(Toolkit):
             # Save file to disk (if output_directory is set)
             file_path = self._save_file_to_disk(content, filename)
 
+            content_bytes = content.encode("utf-8")
+
             # Create FileArtifact
             file_artifact = File(
                 id=str(uuid4()),
-                content=content,
+                content=content_bytes,
                 mime_type="text/plain",
                 file_type="txt",
                 filename=filename,
-                size=len(content.encode("utf-8")),
-                url=f"file://{file_path}" if file_path else None,
+                size=len(content_bytes),
+                filepath=file_path if file_path else None,
             )
 
             log_debug("Text file generated successfully")

agno/tools/firecrawl.py

@@ -101,8 +101,10 @@ class FirecrawlTools(Toolkit):
             The results of the crawling.
         """
         params: Dict[str, Any] = {}
-        if self.limit or limit:
-            params["limit"] = self.limit or limit
+        if self.limit is not None:
+            params["limit"] = self.limit
+        elif limit is not None:
+            params["limit"] = limit
         if self.formats:
             params["scrape_options"] = ScrapeOptions(formats=self.formats)  # type: ignore
 
@@ -129,15 +131,21 @@ class FirecrawlTools(Toolkit):
             limit (int): The maximum number of results to return.
         """
         params: Dict[str, Any] = {}
-        if self.limit or limit:
-            params["limit"] = self.limit or limit
+        if self.limit is not None:
+            params["limit"] = self.limit
+        elif limit is not None:
+            params["limit"] = limit
         if self.formats:
             params["scrape_options"] = ScrapeOptions(formats=self.formats)  # type: ignore
         if self.search_params:
             params.update(self.search_params)
 
         search_result = self.app.search(query, **params)
-        if search_result.success:
-            return json.dumps(search_result.data, cls=CustomJSONEncoder)
+
+        if hasattr(search_result, "success"):
+            if search_result.success:
+                return json.dumps(search_result.data, cls=CustomJSONEncoder)
+            else:
+                return f"Error searching with the Firecrawl tool: {search_result.error}"
         else:
-            return "Error searching with the Firecrawl tool: " + search_result.error
+            return json.dumps(search_result.model_dump(), cls=CustomJSONEncoder)