agno 1.8.1__py3-none-any.whl → 2.0.0__py3-none-any.whl

agno/tools/exa.py

@@ -19,11 +19,15 @@ class ExaTools(Toolkit):
     functionalities to perform categorized searches and retrieve structured results.
 
     Args:
+        enable_search (bool): Enable search functionality. Default is True.
+        enable_get_contents (bool): Enable get contents functionality. Default is True.
+        enable_find_similar (bool): Enable find similar functionality. Default is True.
+        enable_answer (bool): Enable answer generation. Default is True.
+        enable_research (bool): Enable research tool functionality. Default is False.
+        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.
-        answer (bool): Enable answer generation. Default is True.
-        research (bool): Enable research tool functionality. Default is True.
         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`).
@@ -42,11 +46,12 @@ class ExaTools(Toolkit):
 
     def __init__(
         self,
-        search: bool = True,
-        get_contents: bool = True,
-        find_similar: bool = True,
-        answer: bool = True,
-        research: bool = False,
+        enable_search: bool = True,
+        enable_get_contents: bool = True,
+        enable_find_similar: bool = True,
+        enable_answer: bool = True,
+        enable_research: bool = False,
+        all: bool = False,
         text: bool = True,
         text_length_limit: int = 1000,
         highlights: bool = True,
@@ -96,15 +101,15 @@ class ExaTools(Toolkit):
         self.research_model: Literal["exa-research", "exa-research-pro"] = research_model
 
         tools: List[Any] = []
-        if search:
+        if all or enable_search:
             tools.append(self.search_exa)
-        if get_contents:
+        if all or enable_get_contents:
             tools.append(self.get_contents)
-        if find_similar:
+        if all or enable_find_similar:
             tools.append(self.find_similar)
-        if answer:
+        if all or enable_answer:
             tools.append(self.exa_answer)
-        if research:
+        if all or enable_research:
             tools.append(self.research)
 
         super().__init__(name="exa", tools=tools, **kwargs)
@@ -353,14 +358,14 @@ class ExaTools(Toolkit):
             else:
                 task_kwargs["output_infer_schema"] = True
 
-            task_result = self._execute_with_timeout(self.exa.research.create_task, **task_kwargs)
+            task_result = self._execute_with_timeout(self.exa.research.create_task, **task_kwargs)  # type: ignore
             task_id = task_result.id
 
             if self.show_results:
                 log_info(f"Research task created with ID: {task_id}")
 
             # Step 2: Poll until complete (using default polling settings)
-            task = self.exa.research.poll_task(task_id)
+            task = self.exa.research.poll_task(task_id)  # type: ignore
 
             # Step 3: Format and return results
             result: Dict[str, Any] = {"data": task.data, "citations": {}}

agno/tools/fal.py

@@ -7,9 +7,10 @@ from typing import Optional, Union
 from uuid import uuid4
 
 from agno.agent import Agent
-from agno.media import ImageArtifact, VideoArtifact
+from agno.media import Image, Video
 from agno.team.team import Team
 from agno.tools import Toolkit
+from agno.tools.function import ToolResult
 from agno.utils.log import log_info, logger
 
 try:
@@ -23,16 +24,22 @@ class FalTools(Toolkit):
         self,
         api_key: Optional[str] = None,
         model: str = "fal-ai/hunyuan-video",
+        enable_generate_media: bool = True,
+        enable_image_to_image: bool = False,
+        all: bool = False,
         **kwargs,
     ):
-        self.api_key = api_key or getenv("FAL_KEY")
+        self.api_key = api_key or getenv("FAL_API_KEY")
         if not self.api_key:
-            logger.error("FAL_KEY not set. Please set the FAL_KEY environment variable.")
+            logger.error("FAL_API_KEY not set. Please set the FAL_API_KEY environment variable.")
         self.model = model
         self.seen_logs: set[str] = set()
 
         tools = []
-        tools.append(self.generate_media)
+        if all or enable_generate_media:
+            tools.append(self.generate_media)
+        if all or enable_image_to_image:
+            tools.append(self.image_to_image)
 
         super().__init__(name="fal-tools", tools=tools, **kwargs)
 
@@ -44,14 +51,14 @@ class FalTools(Toolkit):
                     log_info(message)
                     self.seen_logs.add(message)
 
-    def generate_media(self, agent: Union[Agent, Team], prompt: str) -> str:
+    def generate_media(self, agent: Union[Agent, Team], prompt: str) -> ToolResult:
         """
         Use this function to run a model with a given prompt.
 
         Args:
             prompt (str): A text description of the task.
         Returns:
-            str: Return the result of the model.
+            ToolResult: Contains the generated media and success message.
         """
         try:
             result = fal_client.subscribe(
@@ -65,32 +72,27 @@ class FalTools(Toolkit):
 
             if "image" in result:
                 url = result.get("image", {}).get("url", "")
-                agent.add_image(
-                    ImageArtifact(
-                        id=media_id,
-                        url=url,
-                    )
+                image_artifact = Image(
+                    id=media_id,
+                    url=url,
                 )
-                media_type = "image"
+                return ToolResult(content=f"Image generated successfully at {url}", images=[image_artifact])
             elif "video" in result:
                 url = result.get("video", {}).get("url", "")
-                agent.add_video(
-                    VideoArtifact(
-                        id=media_id,
-                        url=url,
-                    )
+                video_artifact = Video(
+                    id=media_id,
+                    url=url,
                 )
-                media_type = "video"
+                return ToolResult(content=f"Video generated successfully at {url}", videos=[video_artifact])
             else:
                 logger.error(f"Unsupported type in result: {result}")
-                return f"Unsupported type in result: {result}"
+                return ToolResult(content=f"Unsupported type in result: {result}")
 
-            return f"{media_type.capitalize()} generated successfully at {url}"
         except Exception as e:
             logger.error(f"Failed to run model: {e}")
-            return f"Error: {e}"
+            return ToolResult(content=f"Error: {e}")
 
-    def image_to_image(self, agent: Union[Agent, Team], prompt: str, image_url: Optional[str] = None) -> str:
+    def image_to_image(self, agent: Union[Agent, Team], prompt: str, image_url: Optional[str] = None) -> ToolResult:
         """
         Use this function to transform an input image based on a text prompt using the Fal AI image-to-image model.
         The model takes an existing image and generates a new version modified according to your prompt.
@@ -101,7 +103,7 @@ class FalTools(Toolkit):
             image_url (str): The URL of the image to use for the generation.
 
         Returns:
-            str: Return the result of the model.
+            ToolResult: Contains the generated image and success message.
         """
 
         try:
@@ -113,15 +115,13 @@ class FalTools(Toolkit):
             )
             url = result.get("images", [{}])[0].get("url", "")
             media_id = str(uuid4())
-            agent.add_image(
-                ImageArtifact(
-                    id=media_id,
-                    url=url,
-                )
+            image_artifact = Image(
+                id=media_id,
+                url=url,
             )
 
-            return f"Image generated successfully at {url}"
+            return ToolResult(content=f"Image generated successfully at {url}", images=[image_artifact])
 
         except Exception as e:
             logger.error(f"Failed to generate image: {e}")
-            return f"Error: {e}"
+            return ToolResult(content=f"Error: {e}")

agno/tools/file.py

@@ -10,22 +10,23 @@ class FileTools(Toolkit):
     def __init__(
         self,
         base_dir: Optional[Path] = None,
-        save_files: bool = True,
-        read_files: bool = True,
-        list_files: bool = True,
-        search_files: bool = True,
+        enable_save_file: bool = True,
+        enable_read_file: bool = True,
+        enable_list_files: bool = True,
+        enable_search_files: bool = True,
+        all: bool = False,
         **kwargs,
     ):
         self.base_dir: Path = base_dir or Path.cwd()
 
         tools: List[Any] = []
-        if save_files:
+        if all or enable_save_file:
             tools.append(self.save_file)
-        if read_files:
+        if all or enable_read_file:
             tools.append(self.read_file)
-        if list_files:
+        if all or enable_list_files:
             tools.append(self.list_files)
-        if search_files:
+        if all or enable_search_files:
             tools.append(self.search_files)
 
         super().__init__(name="file_tools", tools=tools, **kwargs)

agno/tools/financial_datasets.py

@@ -11,29 +11,12 @@ class FinancialDatasetsTools(Toolkit):
     def __init__(
         self,
         api_key: Optional[str] = None,
-        enable_financial_statements: bool = True,
-        enable_company_info: bool = True,
-        enable_market_data: bool = True,
-        enable_ownership_data: bool = True,
-        enable_news: bool = True,
-        enable_sec_filings: bool = True,
-        enable_crypto: bool = True,
-        enable_search: bool = True,
         **kwargs,
     ):
-        """
-        Initialize the Financial Datasets Tools with feature flags.
+        """Initialize the Financial Datasets Tools.
 
         Args:
             api_key: API key for Financial Datasets API (optional, can be set via environment variable)
-            enable_financial_statements: Enable financial statement related functions (income statements, balance sheets, etc.)
-            enable_company_info: Enable company information related functions
-            enable_market_data: Enable market data related functions (stock prices, earnings, metrics)
-            enable_ownership_data: Enable ownership data related functions (insider trades, institutional ownership)
-            enable_news: Enable news related functions
-            enable_sec_filings: Enable SEC filings related functions
-            enable_crypto: Enable cryptocurrency related functions
-            enable_search: Enable search related functions
         """
 
         self.api_key: Optional[str] = api_key or getenv("FINANCIAL_DATASETS_API_KEY")
@@ -44,32 +27,30 @@ class FinancialDatasetsTools(Toolkit):
 
         self.base_url = "https://api.financialdatasets.ai"
 
-        tools: List[Any] = []
-
-        if enable_financial_statements:
-            tools.extend(
-                [
-                    self.get_income_statements,
-                    self.get_balance_sheets,
-                    self.get_cash_flow_statements,
-                    self.get_segmented_financials,
-                    self.get_financial_metrics,
-                ]
-            )
-        if enable_company_info:
-            tools.append(self.get_company_info)
-        if enable_market_data:
-            tools.extend([self.get_stock_prices, self.get_earnings])
-        if enable_ownership_data:
-            tools.extend([self.get_insider_trades, self.get_institutional_ownership])
-        if enable_news:
-            tools.append(self.get_news)
-        if enable_sec_filings:
-            tools.append(self.get_sec_filings)
-        if enable_crypto:
-            tools.append(self.get_crypto_prices)
-        if enable_search:
-            tools.append(self.search_tickers)
+        tools: List[Any] = [
+            # Financial statements
+            self.get_income_statements,
+            self.get_balance_sheets,
+            self.get_cash_flow_statements,
+            self.get_segmented_financials,
+            self.get_financial_metrics,
+            # Company info
+            self.get_company_info,
+            # Market data
+            self.get_stock_prices,
+            self.get_earnings,
+            # Ownership data
+            self.get_insider_trades,
+            self.get_institutional_ownership,
+            # News
+            self.get_news,
+            # SEC filings
+            self.get_sec_filings,
+            # Crypto
+            self.get_crypto_prices,
+            # Search
+            self.search_tickers,
+        ]
 
         super().__init__(name="financial_datasets_tools", tools=tools, **kwargs)
 

agno/tools/firecrawl.py

@@ -6,7 +6,8 @@ from agno.tools import Toolkit
 from agno.utils.log import logger
 
 try:
-    from firecrawl import FirecrawlApp, ScrapeOptions  # type: ignore[attr-defined]
+    from firecrawl import FirecrawlApp  # type: ignore[attr-defined]
+    from firecrawl.types import ScrapeOptions
 except ImportError:
     raise ImportError("`firecrawl-py` not installed. Please install using `pip install firecrawl-py`")
 
@@ -24,26 +25,32 @@ class CustomJSONEncoder(json.JSONEncoder):
 class FirecrawlTools(Toolkit):
     """
     Firecrawl is a tool for scraping and crawling websites.
+
     Args:
         api_key (Optional[str]): The API key to use for the Firecrawl app.
+        enable_scrape (bool): Enable website scraping functionality. Default is True.
+        enable_crawl (bool): Enable website crawling functionality. Default is False.
+        enable_mapping (bool): Enable website mapping functionality. Default is False.
+        enable_search (bool): Enable web search functionality. Default is False.
+        all (bool): Enable all tools. Overrides individual flags when True. Default is False.
         formats (Optional[List[str]]): The formats to use for the Firecrawl app.
         limit (int): The maximum number of pages to crawl.
-        scrape (bool): Whether to scrape the website.
-        crawl (bool): Whether to crawl the website.
-        mapping (bool): Whether to map the website.
+        poll_interval (int): Polling interval for crawl operations.
+        search_params (Optional[Dict[str, Any]]): Parameters for search operations.
         api_url (Optional[str]): The API URL to use for the Firecrawl app.
     """
 
     def __init__(
         self,
         api_key: Optional[str] = None,
+        enable_scrape: bool = True,
+        enable_crawl: bool = False,
+        enable_mapping: bool = False,
+        enable_search: bool = False,
+        all: bool = False,
         formats: Optional[List[str]] = None,
         limit: int = 10,
         poll_interval: int = 30,
-        scrape: bool = True,
-        crawl: bool = False,
-        mapping: bool = False,
-        search: bool = False,
         search_params: Optional[Dict[str, Any]] = None,
         api_url: Optional[str] = "https://api.firecrawl.dev",
         **kwargs,
@@ -58,21 +65,14 @@ class FirecrawlTools(Toolkit):
         self.app: FirecrawlApp = FirecrawlApp(api_key=self.api_key, api_url=api_url)
         self.search_params = search_params
 
-        # Start with scrape by default. But if crawl is set, then set scrape to False.
-        if crawl:
-            scrape = False
-            mapping = False
-        elif not scrape:
-            crawl = True
-
         tools: List[Any] = []
-        if scrape:
+        if all or enable_scrape:
             tools.append(self.scrape_website)
-        if crawl:
+        if all or enable_crawl:
             tools.append(self.crawl_website)
-        if mapping:
+        if all or enable_mapping:
             tools.append(self.map_website)
-        if search:
+        if all or enable_search:
             tools.append(self.search)
 
         super().__init__(name="firecrawl_tools", tools=tools, **kwargs)
@@ -87,7 +87,7 @@ class FirecrawlTools(Toolkit):
         if self.formats:
             params["formats"] = self.formats
 
-        scrape_result = self.app.scrape_url(url, **params)
+        scrape_result = self.app.scrape(url, **params)
         return json.dumps(scrape_result.model_dump(), cls=CustomJSONEncoder)
 
     def crawl_website(self, url: str, limit: Optional[int] = None) -> str:
@@ -108,7 +108,7 @@ class FirecrawlTools(Toolkit):
 
         params["poll_interval"] = self.poll_interval
 
-        crawl_result = self.app.crawl_url(url, **params)
+        crawl_result = self.app.crawl(url, **params)
         return json.dumps(crawl_result.model_dump(), cls=CustomJSONEncoder)
 
     def map_website(self, url: str) -> str:
@@ -118,7 +118,7 @@ class FirecrawlTools(Toolkit):
             url (str): The URL to map.
 
         """
-        map_result = self.app.map_url(url)
+        map_result = self.app.map(url)
         return json.dumps(map_result.model_dump(), cls=CustomJSONEncoder)
 
     def search(self, query: str, limit: Optional[int] = None):