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

agno/tools/neo4j.py

@@ -0,0 +1,134 @@
+import os
+from typing import Any, List, Optional
+
+try:
+    from neo4j import GraphDatabase
+except ImportError:
+    raise ImportError("`neo4j` not installed. Please install using `pip install neo4j`")
+
+from agno.tools import Toolkit
+from agno.utils.log import log_debug, logger
+
+
+class Neo4jTools(Toolkit):
+    def __init__(
+        self,
+        uri: Optional[str] = None,
+        user: Optional[str] = None,
+        password: Optional[str] = None,
+        database: Optional[str] = None,
+        # Enable flags for <6 functions
+        enable_list_labels: bool = True,
+        enable_list_relationships: bool = True,
+        enable_get_schema: bool = True,
+        enable_run_cypher: bool = True,
+        all: bool = False,
+        **kwargs,
+    ):
+        """
+        Initialize the Neo4jTools toolkit.
+        Connection parameters (uri/user/password or host/port) can be provided.
+        If not provided, falls back to NEO4J_URI, NEO4J_USERNAME, NEO4J_PASSWORD env vars.
+
+        Args:
+            uri (Optional[str]): The Neo4j URI.
+            user (Optional[str]): The Neo4j username.
+            password (Optional[str]): The Neo4j password.
+            host (Optional[str]): The Neo4j host.
+            port (Optional[int]): The Neo4j port.
+            database (Optional[str]): The Neo4j database.
+            list_labels (bool): Whether to list node labels.
+            list_relationships (bool): Whether to list relationship types.
+            get_schema (bool): Whether to get the schema.
+            run_cypher (bool): Whether to run Cypher queries.
+            **kwargs: Additional keyword arguments.
+        """
+        # Determine the connection URI and credentials
+        uri = uri or os.getenv("NEO4J_URI", "bolt://localhost:7687")
+        user = user or os.getenv("NEO4J_USERNAME")
+        password = password or os.getenv("NEO4J_PASSWORD")
+
+        if user is None or password is None:
+            raise ValueError("Username or password for Neo4j not provided")
+
+        # Create the Neo4j driver
+        try:
+            self.driver = GraphDatabase.driver(uri, auth=(user, password))  # type: ignore
+            self.driver.verify_connectivity()
+            log_debug("Connected to Neo4j database")
+        except Exception as e:
+            logger.error(f"Failed to connect to Neo4j: {e}")
+            raise
+
+        self.database = database or "neo4j"
+
+        # Register toolkit methods as tools
+        tools: List[Any] = []
+        if all or enable_list_labels:
+            tools.append(self.list_labels)
+        if all or enable_list_relationships:
+            tools.append(self.list_relationship_types)
+        if all or enable_get_schema:
+            tools.append(self.get_schema)
+        if all or enable_run_cypher:
+            tools.append(self.run_cypher_query)
+        super().__init__(name="neo4j_tools", tools=tools, **kwargs)
+
+    def list_labels(self) -> list:
+        """
+        Retrieve all node labels present in the connected Neo4j database.
+        """
+        try:
+            log_debug("Listing node labels in Neo4j database")
+            with self.driver.session(database=self.database) as session:
+                result = session.run("CALL db.labels()")
+                labels = [record["label"] for record in result]
+            return labels
+        except Exception as e:
+            logger.error(f"Error listing labels: {e}")
+            return []
+
+    def list_relationship_types(self) -> list:
+        """
+        Retrieve all relationship types present in the connected Neo4j database.
+        """
+        try:
+            log_debug("Listing relationship types in Neo4j database")
+            with self.driver.session(database=self.database) as session:
+                result = session.run("CALL db.relationshipTypes()")
+                types = [record["relationshipType"] for record in result]
+            return types
+        except Exception as e:
+            logger.error(f"Error listing relationship types: {e}")
+            return []
+
+    def get_schema(self) -> list:
+        """
+        Retrieve a visualization of the database schema, including nodes and relationships.
+        """
+        try:
+            log_debug("Retrieving Neo4j schema visualization")
+            with self.driver.session(database=self.database) as session:
+                result = session.run("CALL db.schema.visualization()")
+                schema_data = result.data()
+            return schema_data
+        except Exception as e:
+            logger.error(f"Error getting Neo4j schema: {e}")
+            return []
+
+    def run_cypher_query(self, query: str) -> list:
+        """
+        Execute an arbitrary Cypher query against the connected Neo4j database.
+
+        Args:
+            query (str): The Cypher query string to execute.
+        """
+        try:
+            log_debug(f"Running Cypher query: {query}")
+            with self.driver.session(database=self.database) as session:
+                result = session.run(query)  # type: ignore[arg-type]
+                data = result.data()
+            return data
+        except Exception as e:
+            logger.error(f"Error running Cypher query: {e}")
+            return []

agno/tools/newspaper.py

@@ -14,9 +14,14 @@ class NewspaperTools(Toolkit):
         get_article_text (bool): Whether to get the text of an article from a URL.
     """
 
-    def __init__(self, get_article_text: bool = True, **kwargs):
+    def __init__(
+        self,
+        enable_get_article_text: bool = True,
+        all: bool = False,
+        **kwargs,
+    ):
         tools = []
-        if get_article_text:
+        if all or enable_get_article_text:
             tools.append(self.get_article_text)
 
         super().__init__(name="newspaper_toolkit", tools=tools, **kwargs)

agno/tools/newspaper4k.py

@@ -14,19 +14,24 @@ class Newspaper4kTools(Toolkit):
     """
     Newspaper4kTools is a toolkit for getting the text of an article from a URL.
     Args:
-        read_article (bool): Whether to read an article from a URL.
+        enable_read_article (bool): Whether to read an article from a URL.
         include_summary (bool): Whether to include the summary of an article.
         article_length (Optional[int]): The length of the article to read.
     """
 
     def __init__(
-        self, read_article: bool = True, include_summary: bool = False, article_length: Optional[int] = None, **kwargs
+        self,
+        include_summary: bool = False,
+        article_length: Optional[int] = None,
+        enable_read_article: bool = True,
+        all: bool = False,
+        **kwargs,
     ):
         self.include_summary: bool = include_summary
         self.article_length: Optional[int] = article_length
 
         tools = []
-        if read_article:
+        if all or enable_read_article:
             tools.append(self.read_article)
 
         super().__init__(name="newspaper4k_tools", tools=tools, **kwargs)

agno/tools/openai.py

@@ -6,6 +6,7 @@ from agno.agent import Agent
 from agno.media import AudioArtifact, ImageArtifact
 from agno.team.team import Team
 from agno.tools import Toolkit
+from agno.tools.function import ToolResult
 from agno.utils.log import log_debug, log_error, log_warning
 
 try:
@@ -20,7 +21,23 @@ OpenAITTSFormat = Literal["mp3", "opus", "aac", "flac", "wav", "pcm"]
 
 
 class OpenAITools(Toolkit):
-    """Tools for interacting with OpenAIChat API"""
+    """Tools for interacting with OpenAI API.
+
+    Args:
+        api_key (str, optional): OpenAI API key. Retrieved from OPENAI_API_KEY env variable if not provided.
+        enable_transcription (bool): Enable audio transcription functionality. Default is True.
+        enable_image_generation (bool): Enable image generation functionality. Default is True.
+        enable_speech_generation (bool): Enable speech generation functionality. Default is True.
+        all (bool): Enable all tools. Overrides individual flags when True. Default is False.
+        transcription_model (str): Model to use for transcription. Default is "whisper-1".
+        text_to_speech_voice (OpenAIVoice): Voice to use for TTS. Default is "alloy".
+        text_to_speech_model (OpenAITTSModel): Model to use for TTS. Default is "tts-1".
+        text_to_speech_format (OpenAITTSFormat): Audio format for TTS. Default is "mp3".
+        image_model (str, optional): Model to use for image generation. Default is "dall-e-3".
+        image_quality (str, optional): Quality setting for image generation.
+        image_size (str, optional): Size setting for image generation.
+        image_style (str, optional): Style setting for image generation.
+    """
 
     def __init__(
         self,
@@ -28,6 +45,7 @@ class OpenAITools(Toolkit):
         enable_transcription: bool = True,
         enable_image_generation: bool = True,
         enable_speech_generation: bool = True,
+        all: bool = False,
         transcription_model: str = "whisper-1",
         text_to_speech_voice: OpenAIVoice = "alloy",
         text_to_speech_model: OpenAITTSModel = "tts-1",
@@ -53,11 +71,11 @@ class OpenAITools(Toolkit):
         self.image_size = image_size
 
         tools: List[Any] = []
-        if enable_transcription:
+        if all or enable_transcription:
             tools.append(self.transcribe_audio)
-        if enable_image_generation:
+        if all or enable_image_generation:
             tools.append(self.generate_image)
-        if enable_speech_generation:
+        if all or enable_speech_generation:
             tools.append(self.generate_speech)
 
         super().__init__(name="openai_tools", tools=tools, **kwargs)
@@ -85,14 +103,15 @@ class OpenAITools(Toolkit):
 
     def generate_image(
         self,
-        agent: Union[Agent, Team],
         prompt: str,
-    ) -> str:
+    ) -> ToolResult:
         """Generate images based on a text prompt.
         Args:
             prompt (str): The text prompt to generate the image from.
         """
         try:
+            import base64
+
             extra_params = {
                 "size": self.image_size,
                 "quality": self.image_quality,
@@ -120,29 +139,38 @@ class OpenAITools(Toolkit):
                 data = response.data[0]
             if data is None:
                 log_warning("OpenAI API did not return any data.")
-                return "Failed to generate image: No data received from API."
+                return ToolResult(content="Failed to generate image: No data received from API.")
+
             if hasattr(data, "b64_json") and data.b64_json:
                 image_base64 = data.b64_json
                 media_id = str(uuid4())
-                # Store base64-encoded content as bytes for later saving
-                agent.add_image(
-                    ImageArtifact(
-                        id=media_id,
-                        content=image_base64.encode("utf-8"),
-                        mime_type="image/png",
-                    )
+
+                # Decode base64 to bytes for proper storage
+                image_bytes = base64.b64decode(image_base64)
+
+                # Create ImageArtifact and return in ToolResult
+                image_artifact = ImageArtifact(
+                    id=media_id,
+                    content=image_bytes,  # ← Store as bytes, not encoded string
+                    mime_type="image/png",
+                    original_prompt=prompt,
                 )
-                return "Image generated successfully."
-            return "Failed to generate image: No content received from API."
+
+                return ToolResult(
+                    content="Image generated successfully.",
+                    images=[image_artifact],
+                )
+
+            return ToolResult(content="Failed to generate image: No content received from API.")
         except Exception as e:
             log_error(f"Failed to generate image using {self.image_model}: {e}")
-            return f"Failed to generate image: {e}"
+            return ToolResult(content=f"Failed to generate image: {e}")
 
     def generate_speech(
         self,
         agent: Union[Agent, Team],
         text_input: str,
-    ) -> str:
+    ) -> ToolResult:  # Changed return type
         """Generate speech from text using OpenAI's Text-to-Speech API.
         Args:
             text_input (str): The text to synthesize into speech.
@@ -163,14 +191,17 @@ class OpenAITools(Toolkit):
             # Base64 encode the audio data
             base64_encoded_audio = base64.b64encode(audio_data).decode("utf-8")
 
-            # Create and add AudioArtifact using base64_audio field
+            # Create AudioArtifact and return in ToolResult
             media_id = str(uuid4())
-            agent.add_audio(
-                AudioArtifact(
-                    id=media_id,
-                    base64_audio=base64_encoded_audio,
-                )
+            audio_artifact = AudioArtifact(
+                id=media_id,
+                base64_audio=base64_encoded_audio,
+                mime_type=f"audio/{self.tts_format}",
+            )
+
+            return ToolResult(
+                content=f"Speech generated successfully with ID: {media_id}",
+                audios=[audio_artifact],
             )
-            return f"Speech generated successfully with ID: {media_id}"
         except Exception as e:
-            return f"Failed to generate speech: {str(e)}"
+            return ToolResult(content=f"Failed to generate speech: {str(e)}")

agno/tools/openbb.py

@@ -17,11 +17,12 @@ class OpenBBTools(Toolkit):
         obb: Optional[Any] = None,
         openbb_pat: Optional[str] = None,
         provider: Literal["benzinga", "fmp", "intrinio", "polygon", "tiingo", "tmx", "yfinance"] = "yfinance",
-        stock_price: bool = True,
-        search_symbols: bool = False,
-        company_news: bool = False,
-        company_profile: bool = False,
-        price_targets: bool = False,
+        enable_get_stock_price: bool = True,
+        enable_search_company_symbol: bool = False,
+        enable_get_company_news: bool = False,
+        enable_get_company_profile: bool = False,
+        enable_get_price_targets: bool = False,
+        all: bool = False,
         **kwargs,
     ):
         self.obb = obb or openbb_app
@@ -34,18 +35,18 @@ class OpenBBTools(Toolkit):
         self.provider: Literal["benzinga", "fmp", "intrinio", "polygon", "tiingo", "tmx", "yfinance"] = provider
 
         tools: List[Any] = []
-        if stock_price:
+        if enable_get_stock_price or all:
             tools.append(self.get_stock_price)
-        if search_symbols:
+        if enable_search_company_symbol or all:
             tools.append(self.search_company_symbol)
-        if company_news:
+        if enable_get_company_news or all:
             tools.append(self.get_company_news)
-        if company_profile:
+        if enable_get_company_profile or all:
             tools.append(self.get_company_profile)
-        if price_targets:
+        if enable_get_price_targets or all:
             tools.append(self.get_price_targets)
 
-        super().__init__(name="yfinance_tools", tools=tools, **kwargs)
+        super().__init__(name="openbb_tools", tools=tools, **kwargs)
 
     def get_stock_price(self, symbol: str) -> str:
         """Use this function to get the current stock price for a stock symbol or list of symbols.

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.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 = ImageArtifact(
+                    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 = VideoArtifact(
+                    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)