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

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):

agno/tools/function.py

@@ -8,6 +8,7 @@ from packaging.version import Version
 from pydantic import BaseModel, Field, validate_call
 
 from agno.exceptions import AgentRunException
+from agno.media import AudioArtifact, ImageArtifact, VideoArtifact
 from agno.utils.log import log_debug, log_error, log_exception, log_warning
 
 T = TypeVar("T")
@@ -84,8 +85,6 @@ class Function(BaseModel):
     entrypoint: Optional[Callable] = None
     # If True, the entrypoint processing is skipped and the Function is used as is.
     skip_entrypoint_processing: bool = False
-    # If True, the arguments are sanitized before being passed to the function. (Deprecated)
-    sanitize_arguments: bool = False
     # If True, the function call will show the result along with sending it to the model.
     show_result: bool = False
     # If True, the agent will stop after the function call.
@@ -123,6 +122,8 @@ class Function(BaseModel):
     _agent: Optional[Any] = None
     # The team that the function is associated with
     _team: Optional[Any] = None
+    # The session state that the function is associated with
+    _session_state: Optional[Dict[str, Any]] = None
 
     def to_dict(self) -> Dict[str, Any]:
         return self.model_dump(
@@ -143,17 +144,19 @@ class Function(BaseModel):
             type_hints = get_type_hints(c)
 
             # If function has an the agent argument, remove the agent parameter from the type hints
-            if "agent" in sig.parameters:
+            if "agent" in sig.parameters and "agent" in type_hints:
                 del type_hints["agent"]
-            if "team" in sig.parameters:
+            if "team" in sig.parameters and "team" in type_hints:
                 del type_hints["team"]
+            if "session_state" in sig.parameters and "session_state" in type_hints:
+                del type_hints["session_state"]
             # log_info(f"Type hints for {function_name}: {type_hints}")
 
             # Filter out return type and only process parameters
             param_type_hints = {
                 name: type_hints.get(name)
                 for name in sig.parameters
-                if name != "return" and name not in ["agent", "team", "self"]
+                if name != "return" and name not in ["agent", "team", "session_state", "self"]
             }
 
             # Parse docstring for parameters
@@ -180,14 +183,14 @@ class Function(BaseModel):
             # See: https://platform.openai.com/docs/guides/structured-outputs/supported-schemas#all-fields-must-be-required
             if strict:
                 parameters["required"] = [
-                    name for name in parameters["properties"] if name not in ["agent", "team", "self"]
+                    name for name in parameters["properties"] if name not in ["agent", "team", "session_state", "self"]
                 ]
             else:
                 # Mark a field as required if it has no default value (this would include optional fields)
                 parameters["required"] = [
                     name
                     for name, param in sig.parameters.items()
-                    if param.default == param.empty and name != "self" and name not in ["agent", "team"]
+                    if param.default == param.empty and name not in ["agent", "team", "session_state", "self"]
                 ]
 
             # log_debug(f"JSON schema for {function_name}: {parameters}")
@@ -232,14 +235,16 @@ class Function(BaseModel):
             type_hints = get_type_hints(self.entrypoint)
 
             # If function has an the agent argument, remove the agent parameter from the type hints
-            if "agent" in sig.parameters:
+            if "agent" in sig.parameters and "agent" in type_hints:
                 del type_hints["agent"]
-            if "team" in sig.parameters:
+            if "team" in sig.parameters and "team" in type_hints:
                 del type_hints["team"]
+            if "session_state" in sig.parameters and "session_state" in type_hints:
+                del type_hints["session_state"]
             # log_info(f"Type hints for {self.name}: {type_hints}")
 
             # Filter out return type and only process parameters
-            excluded_params = ["return", "agent", "team", "self"]
+            excluded_params = ["return", "agent", "team", "session_state", "self"]
             if self.requires_user_input and self.user_input_fields:
                 if len(self.user_input_fields) == 0:
                     excluded_params.extend(list(type_hints.keys()))
@@ -352,7 +357,7 @@ class Function(BaseModel):
     def process_schema_for_strict(self):
         self.parameters["additionalProperties"] = False
         self.parameters["required"] = [
-            name for name in self.parameters["properties"] if name not in ["agent", "team", "self"]
+            name for name in self.parameters["properties"] if name not in ["agent", "team", "session_state", "self"]
         ]
 
     def _get_cache_key(self, entrypoint_args: Dict[str, Any], call_args: Optional[Dict[str, Any]] = None) -> str:
@@ -365,6 +370,8 @@ class Function(BaseModel):
             del copy_entrypoint_args["agent"]
         if "team" in copy_entrypoint_args:
             del copy_entrypoint_args["team"]
+        if "session_state" in copy_entrypoint_args:
+            del copy_entrypoint_args["session_state"]
         args_str = str(copy_entrypoint_args)
 
         kwargs_str = str(sorted((call_args or {}).items()))
@@ -425,6 +432,13 @@ class FunctionExecutionResult(BaseModel):
     result: Optional[Any] = None
     error: Optional[str] = None
 
+    updated_session_state: Optional[Dict[str, Any]] = None
+
+    # New fields for media artifacts
+    images: Optional[List[ImageArtifact]] = None
+    videos: Optional[List[VideoArtifact]] = None
+    audios: Optional[List[AudioArtifact]] = None
+
 
 class FunctionCall(BaseModel):
     """Model for Function Calls"""
@@ -480,6 +494,9 @@ 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 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 fc argument
                 if "fc" in signature(self.function.pre_hook).parameters:
                     pre_hook_args["fc"] = self
@@ -505,6 +522,9 @@ 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 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 fc argument
                 if "fc" in signature(self.function.post_hook).parameters:
                     post_hook_args["fc"] = self
@@ -528,6 +548,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 session_state argument
+        if "session_state" in signature(self.function.entrypoint).parameters:  # type: ignore
+            entrypoint_args["session_state"] = self.function._session_state
         # Check if the entrypoint has an fc argument
         if "fc" in signature(self.function.entrypoint).parameters:  # type: ignore
             entrypoint_args["fc"] = self
@@ -544,6 +567,9 @@ 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 session_state argument
+        if "session_state" in signature(hook).parameters:
+            hook_args["session_state"] = self.function._session_state
 
         if "name" in signature(hook).parameters:
             hook_args["name"] = name
@@ -641,10 +667,11 @@ class FunctionCall(BaseModel):
                 execution_chain = self._build_nested_execution_chain(entrypoint_args=entrypoint_args)
                 result = execution_chain(self.function.name, self.function.entrypoint, self.arguments or {})
             else:
-                arguments = entrypoint_args
-                if self.arguments is not None:
-                    arguments.update(self.arguments)
-                result = self.function.entrypoint(**arguments)
+                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")
 
             # Handle generator case
             if isgenerator(result):
@@ -670,7 +697,9 @@ class FunctionCall(BaseModel):
         # Execute post-hook if it exists
         self._handle_post_hook()
 
-        return FunctionExecutionResult(status="success", result=self.result)
+        return FunctionExecutionResult(
+            status="success", result=self.result, updated_session_state=updated_session_state
+        )
 
     async def _handle_pre_hook_async(self):
         """Handles the async pre-hook for the function call."""
@@ -685,6 +714,9 @@ 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 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 fc argument
                 if "fc" in signature(self.function.pre_hook).parameters:
                     pre_hook_args["fc"] = self
@@ -711,6 +743,10 @@ 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 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 fc argument
                 if "fc" in signature(self.function.post_hook).parameters:
                     post_hook_args["fc"] = self
@@ -839,6 +875,10 @@ class FunctionCall(BaseModel):
                 cache_file = self.function._get_cache_file_path(cache_key)
                 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")
+
         except AgentRunException as e:
             log_debug(f"{e.__class__.__name__}: {e}")
             self.error = str(e)
@@ -855,4 +895,15 @@ class FunctionCall(BaseModel):
         else:
             self._handle_post_hook()
 
-        return FunctionExecutionResult(status="success", result=self.result)
+        return FunctionExecutionResult(
+            status="success", result=self.result, updated_session_state=updated_session_state
+        )
+
+
+class ToolResult(BaseModel):
+    """Result from a tool that can include media artifacts."""
+
+    content: str
+    images: Optional[List[ImageArtifact]] = None
+    videos: Optional[List[VideoArtifact]] = None
+    audios: Optional[List[AudioArtifact]] = None

agno/tools/giphy.py

@@ -1,5 +1,5 @@
-import os
 import uuid
+from os import getenv
 from typing import Any, List, Optional, Union
 
 import httpx
@@ -8,6 +8,7 @@ from agno.agent import Agent
 from agno.media import ImageArtifact
 from agno.team.team import Team
 from agno.tools import Toolkit
+from agno.tools.function import ToolResult
 from agno.utils.log import logger
 
 
@@ -16,6 +17,8 @@ class GiphyTools(Toolkit):
         self,
         api_key: Optional[str] = None,
         limit: int = 1,
+        enable_search_gifs: bool = True,
+        all: bool = False,
         **kwargs,
     ):
         """Initialize Giphy tools.
@@ -23,27 +26,29 @@ class GiphyTools(Toolkit):
         Args:
             api_key: Giphy API key. Defaults to GIPHY_API_KEY environment variable.
             limit: Number of GIFs to return. Defaults to 1.
-            search_gifs: Whether to enable GIF search functionality. Defaults to True.
+            enable_search_gifs: Whether to enable GIF search functionality. Defaults to True.
+            all: Enable all functions. Defaults to False.
         """
-        self.api_key = api_key or os.getenv("GIPHY_API_KEY")
+        self.api_key = api_key or getenv("GIPHY_API_KEY")
         if not self.api_key:
             logger.error("No Giphy API key provided")
 
         self.limit: int = limit
 
         tools: List[Any] = []
-        tools.append(self.search_gifs)
+        if all or enable_search_gifs:
+            tools.append(self.search_gifs)
 
         super().__init__(name="giphy_tools", tools=tools, **kwargs)
 
-    def search_gifs(self, agent: Union[Agent, Team], query: str) -> str:
+    def search_gifs(self, agent: Union[Agent, Team], query: str) -> ToolResult:
         """Find a GIPHY gif
 
         Args:
             query (str): A text description of the required gif.
 
         Returns:
-            result (str): A string containing urls of GIFs found
+            ToolResult: Contains the found GIF images or error message.
         """
 
         base_url = "https://api.giphy.com/v1/gifs/search"
@@ -60,6 +65,8 @@ class GiphyTools(Toolkit):
             # Extract the GIF URLs
             data = response.json()
             gif_urls = []
+            image_artifacts = []
+
             for gif in data.get("data", []):
                 images = gif.get("images", {})
                 original_image = images["original"]
@@ -69,13 +76,18 @@ class GiphyTools(Toolkit):
                 alt_text = gif["alt_text"]
                 gif_urls.append(gif_url)
 
-                agent.add_image(ImageArtifact(id=media_id, url=gif_url, alt_text=alt_text, revised_prompt=query))
+                # Create ImageArtifact for the GIF
+                image_artifact = ImageArtifact(id=media_id, url=gif_url, alt_text=alt_text, revised_prompt=query)
+                image_artifacts.append(image_artifact)
 
-            return f"These are the found gifs {gif_urls}"
+            if image_artifacts:
+                return ToolResult(content=f"Found {len(gif_urls)} GIF(s): {gif_urls}", images=image_artifacts)
+            else:
+                return ToolResult(content="No gifs found")
 
         except httpx.HTTPStatusError as e:
             logger.error(f"HTTP error occurred: {e.response.status_code} - {e.response.text}")
+            return ToolResult(content=f"HTTP error occurred: {e.response.status_code}")
         except Exception as e:
             logger.error(f"An error occurred: {e}")
-
-        return "No gifs found"
+            return ToolResult(content=f"An error occurred: {e}")