agno 2.0.4__py3-none-any.whl → 2.0.6__py3-none-any.whl

agno/tools/duckduckgo.py

@@ -12,14 +12,16 @@ except ImportError:
 
 class DuckDuckGoTools(Toolkit):
     """
-    DuckDuckGo is a toolkit for searching DuckDuckGo easily.
+    DuckDuckGo is a toolkit for searching using DuckDuckGo easily.
+    It uses the meta-search library DDGS, so it also has access to other backends.
     Args:
-        search (bool): Enable DuckDuckGo search function.
-        news (bool): Enable DuckDuckGo news function.
+        enable_search (bool): Enable DDGS search function.
+        enable_news (bool): Enable DDGS news function.
         modifier (Optional[str]): A modifier to be used in the search request.
         fixed_max_results (Optional[int]): A fixed number of maximum results.
         proxy (Optional[str]): Proxy to be used in the search request.
         timeout (Optional[int]): The maximum number of seconds to wait for a response.
+        backend (Optional[str]): The backend to be used in the search request.
 
     """
 
@@ -28,6 +30,7 @@ class DuckDuckGoTools(Toolkit):
         enable_search: bool = True,
         enable_news: bool = True,
         all: bool = False,
+        backend: str = "duckduckgo",
         modifier: Optional[str] = None,
         fixed_max_results: Optional[int] = None,
         proxy: Optional[str] = None,
@@ -40,6 +43,7 @@ class DuckDuckGoTools(Toolkit):
         self.fixed_max_results: Optional[int] = fixed_max_results
         self.modifier: Optional[str] = modifier
         self.verify_ssl: bool = verify_ssl
+        self.backend: str = backend
 
         tools: List[Any] = []
         if all or enable_search:
@@ -50,38 +54,38 @@ class DuckDuckGoTools(Toolkit):
         super().__init__(name="duckduckgo", tools=tools, **kwargs)
 
     def duckduckgo_search(self, query: str, max_results: int = 5) -> str:
-        """Use this function to search DuckDuckGo for a query.
+        """Use this function to search DDGS for a query.
 
         Args:
             query(str): The query to search for.
             max_results (optional, default=5): The maximum number of results to return.
 
         Returns:
-            The result from DuckDuckGo.
+            The result from DDGS.
         """
         actual_max_results = self.fixed_max_results or max_results
         search_query = f"{self.modifier} {query}" if self.modifier else query
 
-        log_debug(f"Searching DDG for: {search_query}")
+        log_debug(f"Searching DDG for: {search_query} using backend: {self.backend}")
         with DDGS(proxy=self.proxy, timeout=self.timeout, verify=self.verify_ssl) as ddgs:
-            results = ddgs.text(query=search_query, max_results=actual_max_results)
+            results = ddgs.text(query=search_query, max_results=actual_max_results, backend=self.backend)
 
         return json.dumps(results, indent=2)
 
     def duckduckgo_news(self, query: str, max_results: int = 5) -> str:
-        """Use this function to get the latest news from DuckDuckGo.
+        """Use this function to get the latest news from DDGS.
 
         Args:
             query(str): The query to search for.
             max_results (optional, default=5): The maximum number of results to return.
 
         Returns:
-            The latest news from DuckDuckGo.
+            The latest news from DDGS.
         """
         actual_max_results = self.fixed_max_results or max_results
 
-        log_debug(f"Searching DDG news for: {query}")
+        log_debug(f"Searching DDG news for: {query} using backend: {self.backend}")
         with DDGS(proxy=self.proxy, timeout=self.timeout, verify=self.verify_ssl) as ddgs:
-            results = ddgs.news(query=query, max_results=actual_max_results)
+            results = ddgs.news(query=query, max_results=actual_max_results, backend=self.backend)
 
         return json.dumps(results, indent=2)

agno/tools/e2b.py

@@ -464,7 +464,7 @@ class E2BTools(Toolkit):
 
             result = f"Contents of {directory_path}:\n"
             for file in files:
-                file_type = "Directory" if file.is_dir else "File"
+                file_type = "Directory" if file.type == "directory" else "File"
                 size = f"{file.size} bytes" if file.size is not None else "Unknown size"
                 result += f"- {file.name} ({file_type}, {size})\n"
 
@@ -486,12 +486,19 @@ class E2BTools(Toolkit):
         try:
             content = self.sandbox.files.read(file_path)
 
-            # Try to decode as text if encoding is provided
-            try:
-                text_content = content.decode(encoding)
-                return text_content
-            except UnicodeDecodeError:
-                return f"File read successfully but contains binary data ({len(content)} bytes). Use download_file_from_sandbox to save it."
+            # Check if content is already a string or if it's bytes that need decoding
+            if isinstance(content, str):
+                return content
+            elif isinstance(content, bytes):
+                # Try to decode as text if encoding is provided
+                try:
+                    text_content = content.decode(encoding)
+                    return text_content
+                except UnicodeDecodeError:
+                    return f"File read successfully but contains binary data ({len(content)} bytes). Use download_file_from_sandbox to save it."
+            else:
+                # Handle unexpected content type
+                return f"Unexpected content type: {type(content)}. Expected str or bytes."
 
         except Exception as e:
             return json.dumps({"status": "error", "message": f"Error reading file: {str(e)}"})

agno/tools/file_generation.py

@@ -0,0 +1,350 @@
+import csv
+import io
+import json
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Union
+from uuid import uuid4
+
+from agno.media import File
+from agno.tools import Toolkit
+from agno.tools.function import ToolResult
+from agno.utils.log import log_debug, logger
+
+try:
+    from reportlab.lib.pagesizes import letter
+    from reportlab.lib.styles import getSampleStyleSheet
+    from reportlab.lib.units import inch
+    from reportlab.platypus import Paragraph, SimpleDocTemplate, Spacer
+
+    PDF_AVAILABLE = True
+except ImportError:
+    PDF_AVAILABLE = False
+    logger.warning("reportlab not installed. PDF generation will not be available. Install with: pip install reportlab")
+
+
+class FileGenerationTools(Toolkit):
+    def __init__(
+        self,
+        enable_json_generation: bool = True,
+        enable_csv_generation: bool = True,
+        enable_pdf_generation: bool = True,
+        enable_txt_generation: bool = True,
+        output_directory: Optional[str] = None,
+        all: bool = False,
+        **kwargs,
+    ):
+        self.enable_json_generation = enable_json_generation
+        self.enable_csv_generation = enable_csv_generation
+        self.enable_pdf_generation = enable_pdf_generation and PDF_AVAILABLE
+        self.enable_txt_generation = enable_txt_generation
+        self.output_directory = Path(output_directory) if output_directory else None
+
+        # Create output directory if specified
+        if self.output_directory:
+            self.output_directory.mkdir(parents=True, exist_ok=True)
+            log_debug(f"Files will be saved to: {self.output_directory}")
+
+        if enable_pdf_generation and not PDF_AVAILABLE:
+            logger.warning("PDF generation requested but reportlab is not installed. Disabling PDF generation.")
+            self.enable_pdf_generation = False
+
+        tools: List[Any] = []
+        if all or enable_json_generation:
+            tools.append(self.generate_json_file)
+        if all or enable_csv_generation:
+            tools.append(self.generate_csv_file)
+        if all or (enable_pdf_generation and PDF_AVAILABLE):
+            tools.append(self.generate_pdf_file)
+        if all or enable_txt_generation:
+            tools.append(self.generate_text_file)
+
+        super().__init__(name="file_generation", tools=tools, **kwargs)
+
+    def _save_file_to_disk(self, content: Union[str, bytes], filename: str) -> Optional[str]:
+        """Save file to disk if output_directory is set. Return file path or None."""
+        if not self.output_directory:
+            return None
+
+        file_path = self.output_directory / filename
+
+        if isinstance(content, str):
+            file_path.write_text(content, encoding="utf-8")
+        else:
+            file_path.write_bytes(content)
+
+        log_debug(f"File saved to: {file_path}")
+        return str(file_path)
+
+    def generate_json_file(self, data: Union[Dict, List, str], filename: Optional[str] = None) -> ToolResult:
+        """Generate a JSON file from the provided data.
+
+        Args:
+            data: The data to write to the JSON file. Can be a dictionary, list, or JSON string.
+            filename: Optional filename for the generated file. If not provided, a UUID will be used.
+
+        Returns:
+            ToolResult: Result containing the generated JSON file as a FileArtifact.
+        """
+        try:
+            log_debug(f"Generating JSON file with data: {type(data)}")
+
+            # Handle different input types
+            if isinstance(data, str):
+                try:
+                    json.loads(data)
+                    json_content = data  # Use the original string if it's valid JSON
+                except json.JSONDecodeError:
+                    # If it's not valid JSON, treat as plain text and wrap it
+                    json_content = json.dumps({"content": data}, indent=2)
+            else:
+                json_content = json.dumps(data, indent=2, ensure_ascii=False)
+
+            # Generate filename if not provided
+            if not filename:
+                filename = f"generated_file_{str(uuid4())[:8]}.json"
+            elif not filename.endswith(".json"):
+                filename += ".json"
+
+            # Save file to disk (if output_directory is set)
+            file_path = self._save_file_to_disk(json_content, filename)
+
+            # Create FileArtifact
+            file_artifact = File(
+                id=str(uuid4()),
+                content=json_content,
+                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,
+            )
+
+            log_debug("JSON file generated successfully")
+            success_msg = f"JSON file '{filename}' has been generated successfully with {len(json_content)} characters."
+            if file_path:
+                success_msg += f" File saved to: {file_path}"
+            else:
+                success_msg += " File is available in response."
+
+            return ToolResult(content=success_msg, files=[file_artifact])
+
+        except Exception as e:
+            logger.error(f"Failed to generate JSON file: {e}")
+            return ToolResult(content=f"Error generating JSON file: {e}")
+
+    def generate_csv_file(
+        self,
+        data: Union[List[List], List[Dict], str],
+        filename: Optional[str] = None,
+        headers: Optional[List[str]] = None,
+    ) -> ToolResult:
+        """Generate a CSV file from the provided data.
+
+        Args:
+            data: The data to write to the CSV file. Can be a list of lists, list of dictionaries, or CSV string.
+            filename: Optional filename for the generated file. If not provided, a UUID will be used.
+            headers: Optional headers for the CSV. Used when data is a list of lists.
+
+        Returns:
+            ToolResult: Result containing the generated CSV file as a FileArtifact.
+        """
+        try:
+            log_debug(f"Generating CSV file with data: {type(data)}")
+
+            # Create CSV content
+            output = io.StringIO()
+
+            if isinstance(data, str):
+                # If it's already a CSV string, use it directly
+                csv_content = data
+            elif isinstance(data, list) and len(data) > 0:
+                writer = csv.writer(output)
+
+                if isinstance(data[0], dict):
+                    # List of dictionaries - use keys as headers
+                    if data:
+                        fieldnames = list(data[0].keys())
+                        writer.writerow(fieldnames)
+                        for row in data:
+                            if isinstance(row, dict):
+                                writer.writerow([row.get(field, "") for field in fieldnames])
+                            else:
+                                writer.writerow([str(row)] + [""] * (len(fieldnames) - 1))
+                elif isinstance(data[0], list):
+                    # List of lists
+                    if headers:
+                        writer.writerow(headers)
+                    writer.writerows(data)
+                else:
+                    # List of other types
+                    if headers:
+                        writer.writerow(headers)
+                    for item in data:
+                        writer.writerow([str(item)])
+
+                csv_content = output.getvalue()
+            else:
+                csv_content = ""
+
+            # Generate filename if not provided
+            if not filename:
+                filename = f"generated_file_{str(uuid4())[:8]}.csv"
+            elif not filename.endswith(".csv"):
+                filename += ".csv"
+
+            # Save file to disk (if output_directory is set)
+            file_path = self._save_file_to_disk(csv_content, filename)
+
+            # Create FileArtifact
+            file_artifact = File(
+                id=str(uuid4()),
+                content=csv_content,
+                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,
+            )
+
+            log_debug("CSV file generated successfully")
+            success_msg = f"CSV file '{filename}' has been generated successfully with {len(csv_content)} characters."
+            if file_path:
+                success_msg += f" File saved to: {file_path}"
+            else:
+                success_msg += " File is available in response."
+
+            return ToolResult(content=success_msg, files=[file_artifact])
+
+        except Exception as e:
+            logger.error(f"Failed to generate CSV file: {e}")
+            return ToolResult(content=f"Error generating CSV file: {e}")
+
+    def generate_pdf_file(
+        self, content: str, filename: Optional[str] = None, title: Optional[str] = None
+    ) -> ToolResult:
+        """Generate a PDF file from the provided content.
+
+        Args:
+            content: The text content to write to the PDF file.
+            filename: Optional filename for the generated file. If not provided, a UUID will be used.
+            title: Optional title for the PDF document.
+
+        Returns:
+            ToolResult: Result containing the generated PDF file as a FileArtifact.
+        """
+        if not PDF_AVAILABLE:
+            return ToolResult(
+                content="PDF generation is not available. Please install reportlab: pip install reportlab"
+            )
+
+        try:
+            log_debug(f"Generating PDF file with content length: {len(content)}")
+
+            # Create PDF content in memory
+            buffer = io.BytesIO()
+            doc = SimpleDocTemplate(buffer, pagesize=letter, topMargin=1 * inch)
+
+            # Get styles
+            styles = getSampleStyleSheet()
+            title_style = styles["Title"]
+            normal_style = styles["Normal"]
+
+            # Build story (content elements)
+            story = []
+
+            if title:
+                story.append(Paragraph(title, title_style))
+                story.append(Spacer(1, 20))
+
+            # Split content into paragraphs and add to story
+            paragraphs = content.split("\n\n")
+            for para in paragraphs:
+                if para.strip():
+                    # Clean the paragraph text for PDF
+                    clean_para = para.strip().replace("<", "&lt;").replace(">", "&gt;")
+                    story.append(Paragraph(clean_para, normal_style))
+                    story.append(Spacer(1, 10))
+
+            # Build PDF
+            doc.build(story)
+            pdf_content = buffer.getvalue()
+            buffer.close()
+
+            # Generate filename if not provided
+            if not filename:
+                filename = f"generated_file_{str(uuid4())[:8]}.pdf"
+            elif not filename.endswith(".pdf"):
+                filename += ".pdf"
+
+            # Save file to disk (if output_directory is set)
+            file_path = self._save_file_to_disk(pdf_content, filename)
+
+            # Create FileArtifact
+            file_artifact = File(
+                id=str(uuid4()),
+                content=pdf_content,
+                mime_type="application/pdf",
+                file_type="pdf",
+                filename=filename,
+                size=len(pdf_content),
+                url=f"file://{file_path}" if file_path else None,
+            )
+
+            log_debug("PDF file generated successfully")
+            success_msg = f"PDF file '{filename}' has been generated successfully with {len(pdf_content)} bytes."
+            if file_path:
+                success_msg += f" File saved to: {file_path}"
+            else:
+                success_msg += " File is available in response."
+
+            return ToolResult(content=success_msg, files=[file_artifact])
+
+        except Exception as e:
+            logger.error(f"Failed to generate PDF file: {e}")
+            return ToolResult(content=f"Error generating PDF file: {e}")
+
+    def generate_text_file(self, content: str, filename: Optional[str] = None) -> ToolResult:
+        """Generate a text file from the provided content.
+
+        Args:
+            content: The text content to write to the file.
+            filename: Optional filename for the generated file. If not provided, a UUID will be used.
+
+        Returns:
+            ToolResult: Result containing the generated text file as a FileArtifact.
+        """
+        try:
+            log_debug(f"Generating text file with content length: {len(content)}")
+
+            # Generate filename if not provided
+            if not filename:
+                filename = f"generated_file_{str(uuid4())[:8]}.txt"
+            elif not filename.endswith(".txt"):
+                filename += ".txt"
+
+            # Save file to disk (if output_directory is set)
+            file_path = self._save_file_to_disk(content, filename)
+
+            # Create FileArtifact
+            file_artifact = File(
+                id=str(uuid4()),
+                content=content,
+                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,
+            )
+
+            log_debug("Text file generated successfully")
+            success_msg = f"Text file '{filename}' has been generated successfully with {len(content)} characters."
+            if file_path:
+                success_msg += f" File saved to: {file_path}"
+            else:
+                success_msg += " File is available in response."
+
+            return ToolResult(content=success_msg, files=[file_artifact])
+
+        except Exception as e:
+            logger.error(f"Failed to generate text file: {e}")
+            return ToolResult(content=f"Error generating text file: {e}")

agno/tools/function.py

@@ -485,6 +485,7 @@ class FunctionExecutionResult(BaseModel):
     images: Optional[List[Image]] = None
     videos: Optional[List[Video]] = None
     audios: Optional[List[Audio]] = None
+    files: Optional[List[File]] = None
 
 
 class FunctionCall(BaseModel):
@@ -965,3 +966,4 @@ class ToolResult(BaseModel):
     images: Optional[List[Image]] = None
     videos: Optional[List[Video]] = None
     audios: Optional[List[Audio]] = None
+    files: Optional[List[File]] = None

agno/tools/googlesearch.py

@@ -82,7 +82,7 @@ class GoogleSearchTools(Toolkit):
         log_debug(f"Searching Google [{language}] for: {query}")
 
         # Perform Google search using the googlesearch-python package
-        results = list(search(query, num=max_results, lang=language))
+        results = list(search(query, num_results=max_results, lang=language))
 
         # Collect the search results
         res: List[Dict[str, str]] = []

agno/utils/gemini.py

@@ -146,13 +146,24 @@ def convert_schema(schema_dict: Dict[str, Any], root_schema: Optional[Dict[str,
                 # For Gemini, we need to represent Dict[str, T] as an object with at least one property
                 # to avoid the "properties should be non-empty" error.
                 # We'll create a generic property that represents the dictionary structure
-                value_type = additional_props.get("type", "string").upper()
+
+                # Handle both single types and union types (arrays) from Zod schemas
+                type_value = additional_props.get("type", "string")
+                if isinstance(type_value, list):
+                    value_type = type_value[0].upper() if type_value else "STRING"
+                    union_types = ", ".join(type_value)
+                    type_description_suffix = f" (supports union types: {union_types})"
+                else:
+                    # Single type
+                    value_type = type_value.upper()
+                    type_description_suffix = ""
+
                 # Create a placeholder property to satisfy Gemini's requirements
                 # This is a workaround since Gemini doesn't support additionalProperties directly
                 placeholder_properties = {
                     "example_key": Schema(
                         type=value_type,
-                        description=f"Example key-value pair. This object can contain any number of keys with {value_type.lower()} values.",
+                        description=f"Example key-value pair. This object can contain any number of keys with {value_type.lower()} values{type_description_suffix}.",
                     )
                 }
                 if value_type == "ARRAY":
@@ -162,7 +173,7 @@ def convert_schema(schema_dict: Dict[str, Any], root_schema: Optional[Dict[str,
                     type=Type.OBJECT,
                     properties=placeholder_properties,
                     description=description
-                    or f"Dictionary with {value_type.lower()} values. Can contain any number of key-value pairs.",
+                    or f"Dictionary with {value_type.lower()} values{type_description_suffix}. Can contain any number of key-value pairs.",
                     default=default,
                 )
             else:
@@ -174,7 +185,10 @@ def convert_schema(schema_dict: Dict[str, Any], root_schema: Optional[Dict[str,
             return Schema(type=Type.OBJECT, description=description, default=default)
 
     elif schema_type == "array" and "items" in schema_dict:
-        items = convert_schema(schema_dict["items"], root_schema)
+        if not schema_dict["items"]:  # Handle empty {}
+            items = Schema(type=Type.STRING)
+        else:
+            items = convert_schema(schema_dict["items"], root_schema)
         min_items = schema_dict.get("minItems")
         max_items = schema_dict.get("maxItems")
         return Schema(
@@ -233,6 +247,12 @@ def convert_schema(schema_dict: Dict[str, Any], root_schema: Optional[Dict[str,
                 default=default,
             )
     else:
+        if isinstance(schema_type, list):
+            non_null_types = [t for t in schema_type if t != "null"]
+            if non_null_types:
+                schema_type = non_null_types[0]
+            else:
+                schema_type = ""
         # Only convert to uppercase if schema_type is not empty
         if schema_type:
             schema_type = schema_type.upper()

agno/utils/string.py

@@ -1,7 +1,9 @@
 import hashlib
 import json
 import re
+import uuid
 from typing import Optional, Type
+from uuid import uuid4
 
 from pydantic import BaseModel, ValidationError
 
@@ -188,3 +190,33 @@ def parse_response_model_str(content: str, output_schema: Type[BaseModel]) -> Op
                     logger.warning("All parsing attempts failed.")
 
     return structured_output
+
+
+def generate_id(seed: Optional[str] = None) -> str:
+    """
+    Generate a deterministic UUID5 based on a seed string.
+    If no seed is provided, generate a random UUID4.
+
+    Args:
+        seed (str): The seed string to generate the UUID from.
+
+    Returns:
+        str: A deterministic UUID5 string.
+    """
+    if seed is None:
+        return str(uuid4())
+    return str(uuid.uuid5(uuid.NAMESPACE_DNS, seed))
+
+
+def generate_id_from_name(name: Optional[str] = None) -> str:
+    """
+    Generate a deterministic ID from a name string.
+    If no name is provided, generate a random UUID4.
+
+    Args:
+        name (str): The name string to generate the ID from.
+    """
+    if name:
+        return name.lower().replace(" ", "-").replace("_", "-")
+    else:
+        return str(uuid4())

agno/utils/tools.py

@@ -13,7 +13,7 @@ def get_function_call_for_tool_call(
         _tool_call_function = tool_call.get("function")
         if _tool_call_function is not None:
             _tool_call_function_name = _tool_call_function.get("name")
-            _tool_call_function_arguments_str = _tool_call_function.get("arguments")
+            _tool_call_function_arguments_str = _tool_call_function.get("arguments") or "{}"
             if _tool_call_function_name is not None:
                 return get_function_call(
                     name=_tool_call_function_name,