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

agno/tools/opencv.py

@@ -1,10 +1,12 @@
-import base64
 import time
+from pathlib import Path
+from typing import Callable, List
 from uuid import uuid4
 
 from agno.agent import Agent
-from agno.media import ImageArtifact, VideoArtifact
-from agno.tools.toolkit import Toolkit
+from agno.media import Image, Video
+from agno.tools import Toolkit
+from agno.tools.function import ToolResult
 from agno.utils.log import log_debug, log_error, log_info
 
 try:
@@ -16,30 +18,40 @@ except ImportError:
 class OpenCVTools(Toolkit):
     """Tools for capturing images and videos from the webcam using OpenCV"""
 
-    def __init__(self, show_preview=False, **kwargs):
+    def __init__(
+        self,
+        show_preview=False,
+        enable_capture_image: bool = True,
+        enable_capture_video: bool = True,
+        all: bool = False,
+        **kwargs,
+    ):
+        self.show_preview = show_preview
+
+        tools: List[Callable] = []
+        if all or enable_capture_image:
+            tools.append(self.capture_image)
+        if all or enable_capture_video:
+            tools.append(self.capture_video)
+
         super().__init__(
             name="opencv_tools",
-            tools=[
-                self.capture_image,
-                self.capture_video,
-            ],
+            tools=tools,
             **kwargs,
         )
 
-        self.show_preview = show_preview
-
     def capture_image(
         self,
         agent: Agent,
         prompt: str = "Webcam capture",
-    ) -> str:
+    ) -> ToolResult:
         """Capture an image from the webcam.
 
         Args:
             prompt (str): Description of the image capture. Defaults to "Webcam capture".
 
         Returns:
-            str: A message indicating success or failure.
+            ToolResult: A ToolResult containing the captured image or error message.
         """
         try:
             log_debug("Initializing webcam for image capture...")
@@ -55,7 +67,7 @@ class OpenCVTools(Toolkit):
             if not cam.isOpened():
                 error_msg = "Could not open webcam. Please ensure your terminal has camera permissions and the camera is not being used by another application."
                 log_error(error_msg)
-                return error_msg
+                return ToolResult(content=error_msg)
 
             try:
                 cam.set(cv2.CAP_PROP_FRAME_WIDTH, 1280)
@@ -73,7 +85,7 @@ class OpenCVTools(Toolkit):
                         if not ret:
                             error_msg = "Failed to read frame from webcam"
                             log_error(error_msg)
-                            return error_msg
+                            return ToolResult(content=error_msg)
 
                         cv2.imshow('Camera Preview - Press "c" to capture, "q" to quit', frame)
 
@@ -84,41 +96,42 @@ class OpenCVTools(Toolkit):
                             break
                         elif key == ord("q"):
                             log_info("Capture cancelled by user")
-                            return "Image capture cancelled by user"
+                            return ToolResult(content="Image capture cancelled by user")
                 else:
                     ret, captured_frame = cam.read()
                     if not ret:
                         error_msg = "Failed to capture image from webcam"
                         log_error(error_msg)
-                        return error_msg
+                        return ToolResult(content=error_msg)
 
                 if captured_frame is None:
                     error_msg = "No frame captured"
                     log_error(error_msg)
-                    return error_msg
+                    return ToolResult(content=error_msg)
 
                 success, encoded_image = cv2.imencode(".png", captured_frame)
 
                 if not success:
                     error_msg = "Failed to encode captured image"
                     log_error(error_msg)
-                    return error_msg
+                    return ToolResult(content=error_msg)
 
                 image_bytes = encoded_image.tobytes()
-                base64_encoded_image = base64.b64encode(image_bytes)
-
                 media_id = str(uuid4())
-                agent.add_image(
-                    ImageArtifact(
-                        id=media_id,
-                        content=base64_encoded_image,
-                        original_prompt=prompt,
-                        mime_type="image/png",
-                    )
+
+                # Create ImageArtifact with raw bytes (not base64 encoded)
+                image_artifact = Image(
+                    id=media_id,
+                    content=image_bytes,  # Store as raw bytes
+                    original_prompt=prompt,
+                    mime_type="image/png",
                 )
 
                 log_debug(f"Successfully captured and attached image {media_id}")
-                return "Image captured successfully"
+                return ToolResult(
+                    content="Image captured successfully",
+                    images=[image_artifact],
+                )
 
             finally:
                 # Release the camera and close windows
@@ -129,14 +142,14 @@ class OpenCVTools(Toolkit):
         except Exception as e:
             error_msg = f"Error capturing image: {str(e)}"
             log_error(error_msg)
-            return error_msg
+            return ToolResult(content=error_msg)
 
     def capture_video(
         self,
         agent: Agent,
         duration: int = 10,
         prompt: str = "Webcam video capture",
-    ) -> str:
+    ) -> ToolResult:
         """Capture a video from the webcam.
 
         Args:
@@ -144,7 +157,7 @@ class OpenCVTools(Toolkit):
             prompt (str): Description of the video capture. Defaults to "Webcam video capture".
 
         Returns:
-            str: A message indicating success or failure.
+            ToolResult: A ToolResult containing the captured video or error message.
         """
         try:
             log_debug("Initializing webcam for video capture...")
@@ -161,7 +174,7 @@ class OpenCVTools(Toolkit):
             if not cap.isOpened():
                 error_msg = "Could not open webcam. Please ensure your terminal has camera permissions and the camera is not being used by another application."
                 log_error(error_msg)
-                return error_msg
+                return ToolResult(content=error_msg)
 
             try:
                 frame_width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
@@ -211,7 +224,7 @@ class OpenCVTools(Toolkit):
                 if not out or not out.isOpened():
                     error_msg = "Failed to initialize video writer with any codec"
                     log_error(error_msg)
-                    return error_msg
+                    return ToolResult(content=error_msg)
 
                 start_time = time.time()
                 frame_count = 0
@@ -227,7 +240,7 @@ class OpenCVTools(Toolkit):
                     if not ret:
                         error_msg = "Failed to capture video frame"
                         log_error(error_msg)
-                        return error_msg
+                        return ToolResult(content=error_msg)
 
                     # Write the frame to the output file
                     out.write(frame)
@@ -263,10 +276,11 @@ class OpenCVTools(Toolkit):
                 out.release()
 
                 # Verify the file was created and has content
-                if not os.path.exists(temp_filepath) or os.path.getsize(temp_filepath) == 0:
+                temp_path = Path(temp_filepath)
+                if not temp_path.exists() or temp_path.stat().st_size == 0:
                     error_msg = "Video file was not created or is empty"
                     log_error(error_msg)
-                    return error_msg
+                    return ToolResult(content=error_msg)
 
                 # Read the video file and encode to base64
                 with open(temp_filepath, "rb") as video_file:
@@ -275,23 +289,25 @@ class OpenCVTools(Toolkit):
                 # Clean up temporary file
                 os.unlink(temp_filepath)
 
-                base64_encoded_video = base64.b64encode(video_bytes)
-
                 media_id = str(uuid4())
-                agent.add_video(
-                    VideoArtifact(
-                        id=media_id,
-                        content=base64_encoded_video,
-                        original_prompt=prompt,
-                        mime_type="video/mp4",
-                    )
+
+                # Create VideoArtifact with base64 encoded content
+                video_artifact = Video(
+                    id=media_id,
+                    content=video_bytes,
+                    original_prompt=prompt,
+                    mime_type="video/mp4",
                 )
 
                 actual_duration = time.time() - start_time
                 log_debug(
                     f"Successfully captured and attached video {media_id} ({actual_duration:.1f}s, {frame_count} frames)"
                 )
-                return f"Video captured successfully and attached as artifact {media_id} ({actual_duration:.1f}s, {frame_count} frames, {successful_codec} codec)"
+
+                return ToolResult(
+                    content=f"Video captured successfully and attached as artifact {media_id} ({actual_duration:.1f}s, {frame_count} frames, {successful_codec} codec)",
+                    videos=[video_artifact],
+                )
 
             finally:
                 if "cap" in locals():
@@ -302,4 +318,4 @@ class OpenCVTools(Toolkit):
         except Exception as e:
             error_msg = f"Error capturing video: {str(e)}"
             log_error(error_msg)
-            return error_msg
+            return ToolResult(content=error_msg)

agno/tools/openweather.py

@@ -18,20 +18,22 @@ class OpenWeatherTools(Toolkit):
     Args:
         api_key (Optional[str]): OpenWeatherMap API key. If not provided, will try to get from OPENWEATHER_API_KEY env var.
         units (str): Units of measurement. Options are 'standard', 'metric', and 'imperial'. Default is 'metric'.
-        current_weather (bool): Enable current weather function. Default is True.
-        forecast (bool): Enable forecast function. Default is True.
-        air_pollution (bool): Enable air pollution function. Default is True.
-        geocoding (bool): Enable geocoding function. Default is True.
+        enable_current_weather (bool): Enable current weather function. Default is True.
+        enable_forecast (bool): Enable forecast function. Default is True.
+        enable_air_pollution (bool): Enable air pollution function. Default is True.
+        enable_geocoding (bool): Enable geocoding function. Default is True.
+        all (bool): Enable all functions. Default is False.
     """
 
     def __init__(
         self,
         api_key: Optional[str] = None,
         units: str = "metric",
-        current_weather: bool = True,
-        forecast: bool = True,
-        air_pollution: bool = True,
-        geocoding: bool = True,
+        enable_current_weather: bool = True,
+        enable_forecast: bool = True,
+        enable_air_pollution: bool = True,
+        enable_geocoding: bool = True,
+        all: bool = False,
         **kwargs,
     ):
         self.api_key = api_key or getenv("OPENWEATHER_API_KEY")
@@ -45,13 +47,13 @@ class OpenWeatherTools(Toolkit):
         self.geo_url = "https://api.openweathermap.org/geo/1.0"
 
         tools: List[Any] = []
-        if current_weather:
+        if enable_current_weather or all:
             tools.append(self.get_current_weather)
-        if forecast:
+        if enable_forecast or all:
             tools.append(self.get_forecast)
-        if air_pollution:
+        if enable_air_pollution or all:
             tools.append(self.get_air_pollution)
-        if geocoding:
+        if enable_geocoding or all:
             tools.append(self.geocode_location)
 
         super().__init__(name="openweather_tools", tools=tools, **kwargs)

agno/tools/pandas.py

@@ -10,12 +10,20 @@ except ImportError:
 
 
 class PandasTools(Toolkit):
-    def __init__(self, **kwargs):
+    def __init__(
+        self,
+        enable_create_pandas_dataframe: bool = True,
+        enable_run_dataframe_operation: bool = True,
+        all: bool = False,
+        **kwargs,
+    ):
         self.dataframes: Dict[str, pd.DataFrame] = {}
 
         tools: List[Any] = []
-        tools.append(self.create_pandas_dataframe)
-        tools.append(self.run_dataframe_operation)
+        if all or enable_create_pandas_dataframe:
+            tools.append(self.create_pandas_dataframe)
+        if all or enable_run_dataframe_operation:
+            tools.append(self.run_dataframe_operation)
 
         super().__init__(name="pandas_tools", tools=tools, **kwargs)
 

agno/tools/postgres.py

@@ -22,10 +22,6 @@ class PostgresTools(Toolkit):
         password: Optional[str] = None,
         host: Optional[str] = None,
         port: Optional[int] = None,
-        run_queries: bool = True,
-        inspect_queries: bool = False,
-        summarize_tables: bool = True,
-        export_tables: bool = False,
         table_schema: str = "public",
         **kwargs,
     ):
@@ -40,15 +36,11 @@ class PostgresTools(Toolkit):
         tools: List[Any] = [
             self.show_tables,
             self.describe_table,
+            self.summarize_table,
+            self.inspect_query,
+            self.run_query,
+            self.export_table_to_path,
         ]
-        if inspect_queries:
-            tools.append(self.inspect_query)
-        if run_queries:
-            tools.append(self.run_query)
-        if summarize_tables:
-            tools.append(self.summarize_table)
-        if export_tables:
-            tools.append(self.export_table_to_path)
 
         super().__init__(name="postgres_tools", tools=tools, **kwargs)
 

agno/tools/pubmed.py

@@ -14,6 +14,8 @@ class PubmedTools(Toolkit):
         email: str = "your_email@example.com",
         max_results: Optional[int] = None,
         results_expanded: bool = False,
+        enable_search_pubmed: bool = True,
+        all: bool = False,
         **kwargs,
     ):
         self.max_results: Optional[int] = max_results
@@ -21,7 +23,8 @@ class PubmedTools(Toolkit):
         self.results_expanded: bool = results_expanded
 
         tools: List[Any] = []
-        tools.append(self.search_pubmed)
+        if enable_search_pubmed or all:
+            tools.append(self.search_pubmed)
 
         super().__init__(name="pubmed", tools=tools, **kwargs)
 

agno/tools/python.py

@@ -16,13 +16,6 @@ class PythonTools(Toolkit):
     def __init__(
         self,
         base_dir: Optional[Path] = None,
-        save_and_run: bool = True,
-        pip_install: bool = False,
-        uv_pip_install: bool = False,
-        run_code: bool = False,
-        list_files: bool = False,
-        run_files: bool = False,
-        read_files: bool = False,
         safe_globals: Optional[dict] = None,
         safe_locals: Optional[dict] = None,
         **kwargs,
@@ -33,21 +26,15 @@ class PythonTools(Toolkit):
         self.safe_globals: dict = safe_globals or globals()
         self.safe_locals: dict = safe_locals or locals()
 
-        tools: List[Any] = []
-        if run_code:
-            tools.append(self.run_python_code)
-        if save_and_run:
-            tools.append(self.save_to_file_and_run)
-        if pip_install:
-            tools.append(self.pip_install_package)
-        if uv_pip_install:
-            tools.append(self.uv_pip_install_package)
-        if run_files:
-            tools.append(self.run_python_file_return_variable)
-        if read_files:
-            tools.append(self.read_file)
-        if list_files:
-            tools.append(self.list_files)
+        tools: List[Any] = [
+            self.save_to_file_and_run,
+            self.run_python_code,
+            self.pip_install_package,
+            self.uv_pip_install_package,
+            self.run_python_file_return_variable,
+            self.read_file,
+            self.list_files,
+        ]
 
         super().__init__(name="python_tools", tools=tools, **kwargs)
 

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)