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

agno/tools/reasoning.py

@@ -1,9 +1,7 @@
 from textwrap import dedent
-from typing import Any, List, Optional, Union
+from typing import Any, Dict, List, Optional
 
-from agno.agent import Agent
 from agno.reasoning.step import NextAction, ReasoningStep
-from agno.team.team import Team
 from agno.tools import Toolkit
 from agno.utils.log import log_debug, log_error
 
@@ -11,8 +9,9 @@ from agno.utils.log import log_debug, log_error
 class ReasoningTools(Toolkit):
     def __init__(
         self,
-        think: bool = True,
-        analyze: bool = True,
+        enable_think: bool = True,
+        enable_analyze: bool = True,
+        all: bool = False,
         instructions: Optional[str] = None,
         add_instructions: bool = False,
         add_few_shot: bool = False,
@@ -34,9 +33,10 @@ class ReasoningTools(Toolkit):
             self.instructions = instructions
 
         tools: List[Any] = []
-        if think:
+        # Prefer new flags; fallback to legacy ones
+        if all or enable_think:
             tools.append(self.think)
-        if analyze:
+        if all or enable_analyze:
             tools.append(self.analyze)
 
         super().__init__(
@@ -48,7 +48,12 @@ class ReasoningTools(Toolkit):
         )
 
     def think(
-        self, agent: Union[Agent, Team], title: str, thought: str, action: Optional[str] = None, confidence: float = 0.8
+        self,
+        session_state: Dict[str, Any],
+        title: str,
+        thought: str,
+        action: Optional[str] = None,
+        confidence: float = 0.8,
     ) -> str:
         """Use this tool as a scratchpad to reason about the question and work through it step-by-step.
         This tool will help you break down complex problems into logical steps and track the reasoning process.
@@ -75,19 +80,21 @@ class ReasoningTools(Toolkit):
                 confidence=confidence,
             )
 
+            current_run_id = session_state.get("current_run_id", None)
+
             # Add this step to the Agent's session state
-            if agent.session_state is None:
-                agent.session_state = {}
-            if "reasoning_steps" not in agent.session_state:
-                agent.session_state["reasoning_steps"] = {}
-            if agent.run_id not in agent.session_state["reasoning_steps"]:
-                agent.session_state["reasoning_steps"][agent.run_id] = []
-            agent.session_state["reasoning_steps"][agent.run_id].append(reasoning_step.model_dump_json())
+            if session_state is None:
+                session_state = {}
+            if "reasoning_steps" not in session_state:
+                session_state["reasoning_steps"] = {}
+            if current_run_id not in session_state["reasoning_steps"]:
+                session_state["reasoning_steps"][current_run_id] = []
+            session_state["reasoning_steps"][current_run_id].append(reasoning_step.model_dump_json())
 
             # Return all previous reasoning_steps and the new reasoning_step
-            if "reasoning_steps" in agent.session_state and agent.run_id in agent.session_state["reasoning_steps"]:
+            if "reasoning_steps" in session_state and current_run_id in session_state["reasoning_steps"]:
                 formatted_reasoning_steps = ""
-                for i, step in enumerate(agent.session_state["reasoning_steps"][agent.run_id], 1):
+                for i, step in enumerate(session_state["reasoning_steps"][current_run_id], 1):
                     step_parsed = ReasoningStep.model_validate_json(step)
                     step_str = dedent(f"""\
 Step {i}:
@@ -105,7 +112,7 @@ Confidence: {step_parsed.confidence}
 
     def analyze(
         self,
-        agent: Union[Agent, Team],
+        session_state: Dict[str, Any],
         title: str,
         result: str,
         analysis: str,
@@ -143,19 +150,20 @@ Confidence: {step_parsed.confidence}
                 confidence=confidence,
             )
 
+            current_run_id = session_state.get("current_run_id", None)
             # Add this step to the Agent's session state
-            if agent.session_state is None:
-                agent.session_state = {}
-            if "reasoning_steps" not in agent.session_state:
-                agent.session_state["reasoning_steps"] = {}
-            if agent.run_id not in agent.session_state["reasoning_steps"]:
-                agent.session_state["reasoning_steps"][agent.run_id] = []
-            agent.session_state["reasoning_steps"][agent.run_id].append(reasoning_step.model_dump_json())
+            if session_state is None:
+                session_state = {}
+            if "reasoning_steps" not in session_state:
+                session_state["reasoning_steps"] = {}
+            if current_run_id not in session_state["reasoning_steps"]:
+                session_state["reasoning_steps"][current_run_id] = []
+            session_state["reasoning_steps"][current_run_id].append(reasoning_step.model_dump_json())
 
             # Return all previous reasoning_steps and the new reasoning_step
-            if "reasoning_steps" in agent.session_state and agent.run_id in agent.session_state["reasoning_steps"]:
+            if "reasoning_steps" in session_state and current_run_id in session_state["reasoning_steps"]:
                 formatted_reasoning_steps = ""
-                for i, step in enumerate(agent.session_state["reasoning_steps"][agent.run_id], 1):
+                for i, step in enumerate(session_state["reasoning_steps"][current_run_id], 1):
                     step_parsed = ReasoningStep.model_validate_json(step)
                     step_str = dedent(f"""\
 Step {i}:

agno/tools/reddit.py

@@ -1,6 +1,6 @@
 import json
 from os import getenv
-from typing import Any, Dict, List, Optional, Union
+from typing import Callable, Dict, List, Optional, Union
 
 from agno.tools import Toolkit
 from agno.utils.log import log_debug, log_info, logger
@@ -20,14 +20,6 @@ class RedditTools(Toolkit):
         user_agent: Optional[str] = None,
         username: Optional[str] = None,
         password: Optional[str] = None,
-        get_user_info: bool = True,
-        get_top_posts: bool = True,
-        get_subreddit_info: bool = True,
-        get_trending_subreddits: bool = True,
-        get_subreddit_stats: bool = True,
-        create_post: bool = True,
-        reply_to_post: bool = True,
-        reply_to_comment: bool = True,
         **kwargs,
     ):
         if reddit_instance is not None:
@@ -65,23 +57,16 @@ class RedditTools(Toolkit):
             else:
                 logger.warning("Missing Reddit API credentials")
 
-        tools: List[Any] = []
-        if get_user_info:
-            tools.append(self.get_user_info)
-        if get_top_posts:
-            tools.append(self.get_top_posts)
-        if get_subreddit_info:
-            tools.append(self.get_subreddit_info)
-        if get_trending_subreddits:
-            tools.append(self.get_trending_subreddits)
-        if get_subreddit_stats:
-            tools.append(self.get_subreddit_stats)
-        if create_post:
-            tools.append(self.create_post)
-        if reply_to_post:
-            tools.append(self.reply_to_post)
-        if reply_to_comment:
-            tools.append(self.reply_to_comment)
+        tools: List[Callable] = [
+            self.get_user_info,
+            self.get_top_posts,
+            self.get_subreddit_info,
+            self.get_trending_subreddits,
+            self.get_subreddit_stats,
+            self.create_post,
+            self.reply_to_post,
+            self.reply_to_comment,
+        ]
 
         super().__init__(name="reddit", tools=tools, **kwargs)
 

agno/tools/replicate.py

@@ -1,6 +1,6 @@
-import os
 from os import getenv
-from typing import Any, Iterable, Iterator, List, Optional, Union
+from pathlib import Path
+from typing import Any, Iterable, Iterator, List, Optional, Tuple, Union
 from urllib.parse import urlparse
 from uuid import uuid4
 
@@ -8,6 +8,7 @@ from agno.agent import Agent
 from agno.media import ImageArtifact, VideoArtifact
 from agno.team.team import Team
 from agno.tools import Toolkit
+from agno.tools.function import ToolResult
 from agno.utils.log import logger
 
 try:
@@ -22,83 +23,95 @@ class ReplicateTools(Toolkit):
         self,
         api_key: Optional[str] = None,
         model: str = "minimax/video-01",
+        enable_generate_media: bool = True,
+        all: bool = False,
         **kwargs,
     ):
-        self.api_key = api_key or getenv("REPLICATE_API_TOKEN")
+        self.api_key = api_key or getenv("REPLICATE_API_KEY")
         if not self.api_key:
-            logger.error("REPLICATE_API_TOKEN not set. Please set the REPLICATE_API_TOKEN environment variable.")
+            logger.error("REPLICATE_API_KEY not set. Please set the REPLICATE_API_KEY environment variable.")
         self.model = model
 
         tools: List[Any] = []
-        tools.append(self.generate_media)
+        if all or enable_generate_media:
+            tools.append(self.generate_media)
 
         super().__init__(name="replicate_toolkit", tools=tools, **kwargs)
 
-    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 generate an image or a video using a replicate model.
         Args:
             prompt (str): A text description of the content.
         Returns:
-            str: Return a URI to the generated video or image.
+            ToolResult: A ToolResult containing the generated media or error message.
         """
         if not self.api_key:
             logger.error("API key is not set. Please provide a valid API key.")
-            return "API key is not set."
+            return ToolResult(content="API key is not set.")
 
-        outputs = replicate.run(ref=self.model, input={"prompt": prompt})
-        if isinstance(outputs, FileOutput):
-            outputs = [outputs]
-        elif isinstance(outputs, (Iterable, Iterator)) and not isinstance(outputs, str):
-            outputs = list(outputs)
-        else:
-            logger.error(f"Unexpected output type: {type(outputs)}")
-            return f"Unexpected output type: {type(outputs)}"
+        try:
+            outputs = replicate.run(ref=self.model, input={"prompt": prompt})
+            if isinstance(outputs, FileOutput):
+                outputs = [outputs]
+            elif isinstance(outputs, (Iterable, Iterator)) and not isinstance(outputs, str):
+                outputs = list(outputs)
+            else:
+                logger.error(f"Unexpected output type: {type(outputs)}")
+                return ToolResult(content=f"Unexpected output type: {type(outputs)}")
+
+            images = []
+            videos = []
+            results = []
 
-        results = []
-        for output in outputs:
-            if not isinstance(output, FileOutput):
-                logger.error(f"Unexpected output type: {type(output)}")
-                return f"Unexpected output type: {type(output)}"
+            for output in outputs:
+                if not isinstance(output, FileOutput):
+                    logger.error(f"Unexpected output type: {type(output)}")
+                    return ToolResult(content=f"Unexpected output type: {type(output)}")
 
-            result = self._parse_output(agent, output)
-            results.append(result)
-        return "\n".join(results)
+                result_msg, media_artifact = self._parse_output(output)
+                results.append(result_msg)
 
-    def _parse_output(self, agent: Union[Agent, Team], output: FileOutput) -> str:
+                if isinstance(media_artifact, ImageArtifact):
+                    images.append(media_artifact)
+                elif isinstance(media_artifact, VideoArtifact):
+                    videos.append(media_artifact)
+
+            content = "\n".join(results)
+            return ToolResult(
+                content=content,
+                images=images if images else None,
+                videos=videos if videos else None,
+            )
+        except Exception as e:
+            logger.error(f"Failed to generate media: {e}")
+            return ToolResult(content=f"Error: {e}")
+
+    def _parse_output(self, output: FileOutput) -> Tuple[str, Union[ImageArtifact, VideoArtifact]]:
         """
         Parse the outputs from the replicate model.
         """
         # Parse the URL to extract the file extension
         parsed_url = urlparse(output.url)
         path = parsed_url.path
-        _, ext = os.path.splitext(path)
-        ext = ext.lower()
+        ext = Path(path).suffix.lower()
 
         # Define supported extensions
         image_extensions = {".jpg", ".jpeg", ".png", ".gif", ".bmp", ".tiff", ".webp"}
         video_extensions = {".mp4", ".mov", ".avi", ".mkv", ".flv", ".wmv", ".webm"}
 
         media_id = str(uuid4())
+        artifact: Union[ImageArtifact, VideoArtifact]
+        media_type: str
 
         if ext in image_extensions:
-            agent.add_image(
-                ImageArtifact(
-                    id=media_id,
-                    url=output.url,
-                )
-            )
+            artifact = ImageArtifact(id=media_id, url=output.url)
             media_type = "image"
         elif ext in video_extensions:
-            agent.add_video(
-                VideoArtifact(
-                    id=media_id,
-                    url=output.url,
-                )
-            )
+            artifact = VideoArtifact(id=media_id, url=output.url)
             media_type = "video"
         else:
             logger.error(f"Unsupported media type with extension '{ext}' for URL: {output.url}")
-            return f"Unsupported media type with extension '{ext}'."
+            raise ValueError(f"Unsupported media type with extension '{ext}'.")
 
-        return f"{media_type.capitalize()} generated successfully at {output.url}"
+        return f"{media_type.capitalize()} generated successfully at {output.url}", artifact

agno/tools/resend.py

@@ -15,6 +15,8 @@ class ResendTools(Toolkit):
         self,
         api_key: Optional[str] = None,
         from_email: Optional[str] = None,
+        enable_send_email: bool = True,
+        all: bool = False,
         **kwargs,
     ):
         self.from_email = from_email
@@ -23,7 +25,8 @@ class ResendTools(Toolkit):
             logger.error("No Resend API key provided")
 
         tools: List[Any] = []
-        tools.append(self.send_email)
+        if all or enable_send_email:
+            tools.append(self.send_email)
 
         super().__init__(name="resend_tools", tools=tools, **kwargs)
 

agno/tools/scrapegraph.py

@@ -1,5 +1,5 @@
 import json
-import os
+from os import getenv
 from typing import Any, List, Optional
 
 from agno.tools import Toolkit
@@ -18,31 +18,32 @@ class ScrapeGraphTools(Toolkit):
     def __init__(
         self,
         api_key: Optional[str] = None,
-        smartscraper: bool = True,
-        markdownify: bool = False,
-        crawl: bool = False,
-        searchscraper: bool = False,
-        agentic_crawler: bool = False,
+        enable_smartscraper: bool = True,
+        enable_markdownify: bool = False,
+        enable_crawl: bool = False,
+        enable_searchscraper: bool = False,
+        enable_agentic_crawler: bool = False,
+        all: bool = False,
         **kwargs,
     ):
-        self.api_key: Optional[str] = api_key or os.getenv("SGAI_API_KEY")
+        self.api_key: Optional[str] = api_key or getenv("SGAI_API_KEY")
         self.client = Client(api_key=self.api_key)
 
         # Start with smartscraper by default
         # Only enable markdownify if smartscraper is False
-        if not smartscraper:
-            markdownify = True
+        if not enable_smartscraper and not all:
+            enable_markdownify = True
 
         tools: List[Any] = []
-        if smartscraper:
+        if enable_smartscraper or all:
             tools.append(self.smartscraper)
-        if markdownify:
+        if enable_markdownify or all:
             tools.append(self.markdownify)
-        if crawl:
+        if enable_crawl or all:
             tools.append(self.crawl)
-        if searchscraper:
+        if enable_searchscraper or all:
             tools.append(self.searchscraper)
-        if agentic_crawler:
+        if enable_agentic_crawler or all:
             tools.append(self.agentic_crawler)
 
         super().__init__(name="scrapegraph_tools", tools=tools, **kwargs)

agno/tools/searxng.py

@@ -14,35 +14,22 @@ class Searxng(Toolkit):
         host: str,
         engines: List[str] = [],
         fixed_max_results: Optional[int] = None,
-        images: bool = False,
-        it: bool = False,
-        map: bool = False,
-        music: bool = False,
-        news: bool = False,
-        science: bool = False,
-        videos: bool = False,
         **kwargs,
     ):
         self.host = host
         self.engines = engines
         self.fixed_max_results = fixed_max_results
 
-        tools: List[Any] = []
-        tools.append(self.search)
-        if images:
-            tools.append(self.image_search)
-        if it:
-            tools.append(self.it_search)
-        if map:
-            tools.append(self.map_search)
-        if music:
-            tools.append(self.music_search)
-        if news:
-            tools.append(self.news_search)
-        if science:
-            tools.append(self.science_search)
-        if videos:
-            tools.append(self.video_search)
+        tools: List[Any] = [
+            self.search,
+            self.image_search,
+            self.it_search,
+            self.map_search,
+            self.music_search,
+            self.news_search,
+            self.science_search,
+            self.video_search,
+        ]
 
         super().__init__(name="searxng", tools=tools, **kwargs)
 

agno/tools/serpapi.py

@@ -15,7 +15,9 @@ class SerpApiTools(Toolkit):
     def __init__(
         self,
         api_key: Optional[str] = None,
-        search_youtube: bool = False,
+        enable_search_google: bool = True,
+        enable_search_youtube: bool = False,
+        all: bool = False,
         **kwargs,
     ):
         self.api_key = api_key or getenv("SERP_API_KEY")
@@ -23,8 +25,9 @@ class SerpApiTools(Toolkit):
             logger.warning("No Serpapi API key provided")
 
         tools: List[Any] = []
-        tools.append(self.search_google)
-        if search_youtube:
+        if all or enable_search_google:
+            tools.append(self.search_google)
+        if all or enable_search_youtube:
             tools.append(self.search_youtube)
 
         super().__init__(name="serpapi_tools", tools=tools, **kwargs)

agno/tools/serper.py

@@ -16,6 +16,11 @@ class SerperTools(Toolkit):
         language: str = "en",
         num_results: int = 10,
         date_range: Optional[str] = None,
+        enable_search: bool = True,
+        enable_search_news: bool = True,
+        enable_search_scholar: bool = True,
+        enable_scrape_webpage: bool = True,
+        all: bool = False,
         **kwargs,
     ):
         """
@@ -38,10 +43,14 @@ class SerperTools(Toolkit):
         self.date_range = date_range
 
         tools: List[Any] = []
-        tools.append(self.search)
-        tools.append(self.search_news)
-        tools.append(self.search_scholar)
-        tools.append(self.scrape_webpage)
+        if all or enable_search:
+            tools.append(self.search)
+        if all or enable_search_news:
+            tools.append(self.search_news)
+        if all or enable_search_scholar:
+            tools.append(self.search_scholar)
+        if all or enable_scrape_webpage:
+            tools.append(self.scrape_webpage)
 
         super().__init__(name="serper_tools", tools=tools, **kwargs)
 

agno/tools/shell.py

@@ -6,13 +6,20 @@ from agno.utils.log import log_debug, log_info, logger
 
 
 class ShellTools(Toolkit):
-    def __init__(self, base_dir: Optional[Union[Path, str]] = None, **kwargs):
+    def __init__(
+        self,
+        base_dir: Optional[Union[Path, str]] = None,
+        enable_run_shell_command: bool = True,
+        all: bool = False,
+        **kwargs,
+    ):
         self.base_dir: Optional[Path] = None
         if base_dir is not None:
             self.base_dir = Path(base_dir) if isinstance(base_dir, str) else base_dir
 
         tools = []
-        tools.append(self.run_shell_command)
+        if all or enable_run_shell_command:
+            tools.append(self.run_shell_command)
 
         super().__init__(name="shell_tools", tools=tools, **kwargs)
 

agno/tools/slack.py

@@ -1,8 +1,8 @@
 import json
-import os
+from os import getenv
 from typing import Any, Dict, List, Optional
 
-from agno.tools.toolkit import Toolkit
+from agno.tools import Toolkit
 from agno.utils.log import logger
 
 try:
@@ -16,25 +16,26 @@ class SlackTools(Toolkit):
     def __init__(
         self,
         token: Optional[str] = None,
-        send_message: bool = True,
-        send_message_thread: bool = True,
-        list_channels: bool = True,
-        get_channel_history: bool = True,
+        enable_send_message: bool = True,
+        enable_send_message_thread: bool = True,
+        enable_list_channels: bool = True,
+        enable_get_channel_history: bool = True,
+        all: bool = False,
         **kwargs,
     ):
-        self.token: Optional[str] = token or os.getenv("SLACK_TOKEN")
+        self.token: Optional[str] = token or getenv("SLACK_TOKEN")
         if self.token is None or self.token == "":
             raise ValueError("SLACK_TOKEN is not set")
         self.client = WebClient(token=self.token)
 
         tools: List[Any] = []
-        if send_message:
+        if enable_send_message or all:
             tools.append(self.send_message)
-        if send_message_thread:
+        if enable_send_message_thread or all:
             tools.append(self.send_message_thread)
-        if list_channels:
+        if enable_list_channels or all:
             tools.append(self.list_channels)
-        if get_channel_history:
+        if enable_get_channel_history or all:
             tools.append(self.get_channel_history)
 
         super().__init__(name="slack", tools=tools, **kwargs)

agno/tools/sleep.py

@@ -5,9 +5,10 @@ from agno.utils.log import log_info
 
 
 class SleepTools(Toolkit):
-    def __init__(self, **kwargs):
+    def __init__(self, enable_sleep: bool = True, all: bool = False, **kwargs):
         tools = []
-        tools.append(self.sleep)
+        if all or enable_sleep:
+            tools.append(self.sleep)
 
         super().__init__(name="sleep", tools=tools, **kwargs)
 

agno/tools/spider.py

@@ -7,16 +7,33 @@ except ImportError:
 
 from typing import Any, List, Optional
 
-from agno.tools.toolkit import Toolkit
+from agno.tools import Toolkit
 from agno.utils.log import log_info, logger
 
 
 class SpiderTools(Toolkit):
+    """
+    Spider is a toolkit for web searching, scraping, and crawling.
+
+    Args:
+        enable_search (bool): Enable web search functionality. Default is True.
+        enable_scrape (bool): Enable web scraping functionality. Default is True.
+        enable_crawl (bool): Enable web crawling functionality. Default is True.
+        all (bool): Enable all tools. Overrides individual flags when True. Default is False.
+        max_results (Optional[int]): Default maximum number of results.
+        url (Optional[str]): Default URL for operations.
+        optional_params (Optional[dict]): Additional parameters for operations.
+    """
+
     def __init__(
         self,
         max_results: Optional[int] = None,
         url: Optional[str] = None,
         optional_params: Optional[dict] = None,
+        enable_search: bool = True,
+        enable_scrape: bool = True,
+        enable_crawl: bool = True,
+        all: bool = False,
         **kwargs,
     ):
         self.max_results = max_results
@@ -24,9 +41,12 @@ class SpiderTools(Toolkit):
         self.optional_params = optional_params or {}
 
         tools: List[Any] = []
-        tools.append(self.search)
-        tools.append(self.scrape)
-        tools.append(self.crawl)
+        if enable_search or all:
+            tools.append(self.search)
+        if enable_scrape or all:
+            tools.append(self.scrape)
+        if enable_crawl or all:
+            tools.append(self.crawl)
 
         super().__init__(name="spider", tools=tools, **kwargs)
 

agno/tools/sql.py

@@ -25,9 +25,10 @@ class SQLTools(Toolkit):
         schema: Optional[str] = None,
         dialect: Optional[str] = None,
         tables: Optional[Dict[str, Any]] = None,
-        list_tables: bool = True,
-        describe_table: bool = True,
-        run_sql_query: bool = True,
+        enable_list_tables: bool = True,
+        enable_describe_table: bool = True,
+        enable_run_sql_query: bool = True,
+        all: bool = False,
         **kwargs,
     ):
         # Get the database engine
@@ -53,11 +54,11 @@ class SQLTools(Toolkit):
         self.tables: Optional[Dict[str, Any]] = tables
 
         tools: List[Any] = []
-        if list_tables:
+        if enable_list_tables or all:
             tools.append(self.list_tables)
-        if describe_table:
+        if enable_describe_table or all:
             tools.append(self.describe_table)
-        if run_sql_query:
+        if enable_run_sql_query or all:
             tools.append(self.run_sql_query)
 
         super().__init__(name="sql_tools", tools=tools, **kwargs)