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

agno/tools/models/groq.py

@@ -1,12 +1,12 @@
-import base64
-import os
 from os import getenv
-from typing import Optional
+from pathlib import Path
+from typing import Any, List, Optional
 from uuid import uuid4
 
 from agno.agent import Agent
-from agno.media import AudioArtifact
+from agno.media import Audio
 from agno.tools import Toolkit
+from agno.tools.function import ToolResult
 from agno.utils.log import log_debug, log_error
 
 try:
@@ -25,11 +25,21 @@ class GroqTools(Toolkit):
         translation_model: str = "whisper-large-v3",
         tts_model: str = "playai-tts",
         tts_voice: str = "Chip-PlayAI",
+        enable_transcribe_audio: bool = True,
+        enable_translate_audio: bool = True,
+        enable_generate_speech: bool = True,
+        all: bool = False,
         **kwargs,
     ):
-        super().__init__(
-            name="groq_tools", tools=[self.transcribe_audio, self.translate_audio, self.generate_speech], **kwargs
-        )
+        tools: List[Any] = []
+        if all or enable_transcribe_audio:
+            tools.append(self.transcribe_audio)
+        if all or enable_translate_audio:
+            tools.append(self.translate_audio)
+        if all or enable_generate_speech:
+            tools.append(self.generate_speech)
+
+        super().__init__(name="groq_tools", tools=tools, **kwargs)
 
         self.api_key = api_key or getenv("GROQ_API_KEY")
         if not self.api_key:
@@ -52,7 +62,7 @@ class GroqTools(Toolkit):
         log_debug(f"Transcribing audio from {audio_source} using Groq model {self.transcription_model}")
         try:
             # Check if the audio source as a local file or a URL
-            if not os.path.exists(audio_source):
+            if not Path(audio_source).exists():
                 log_debug(f"Audio source '{audio_source}' not found locally, attempting as URL.")
                 transcription_text = self.client.audio.transcriptions.create(
                     url=audio_source,
@@ -63,7 +73,7 @@ class GroqTools(Toolkit):
                 log_debug(f"Transcribing local file: {audio_source}")
                 with open(audio_source, "rb") as audio_file:
                     transcription_text = self.client.audio.transcriptions.create(
-                        file=(os.path.basename(audio_source), audio_file.read()),
+                        file=(Path(audio_source).name, audio_file.read()),
                         model=self.transcription_model,
                         response_format="text",
                     )
@@ -83,7 +93,7 @@ class GroqTools(Toolkit):
         """
         log_debug(f"Translating audio from {audio_source} to English using Groq model {self.translation_model}")
         try:
-            if not os.path.exists(audio_source):
+            if not Path(audio_source).exists():
                 log_debug(f"Audio source '{audio_source}' not found locally.")
                 translation = self.client.audio.translations.create(
                     url=audio_source,
@@ -94,7 +104,7 @@ class GroqTools(Toolkit):
                 log_debug(f"Translating local file: {audio_source}")
                 with open(audio_source, "rb") as audio_file:
                     translation = self.client.audio.translations.create(
-                        file=(os.path.basename(audio_source), audio_file.read()),
+                        file=(Path(audio_source).name, audio_file.read()),
                         model=self.translation_model,
                         response_format="text",
                     )
@@ -109,14 +119,13 @@ class GroqTools(Toolkit):
         self,
         agent: Agent,
         text_input: str,
-    ) -> str:
+    ) -> ToolResult:
         """Generate speech from text using Groq's Text-to-Speech API.
-        Adds the generated audio as an AudioArtifact to the agent.
 
         Args:
             text_input: The text to synthesize into speech.
         Returns:
-            str: A success message with the audio artifact ID or an error message.
+            ToolResult: Contains the generated audio artifact or error message.
         """
         log_debug(
             f"Generating speech for text: '{text_input[:50]}...' using Groq model {self.tts_model}, voice {self.tts_voice}"
@@ -133,19 +142,17 @@ class GroqTools(Toolkit):
             log_debug(f"Groq TTS Response: {response}")
 
             audio_data: bytes = response.read()
-            base64_encoded_audio = base64.b64encode(audio_data).decode("utf-8")
 
             media_id = str(uuid4())
-            agent.add_audio(
-                AudioArtifact(
-                    id=media_id,
-                    base64_audio=base64_encoded_audio,
-                    mime_type="audio/wav",
-                )
+            audio_artifact = Audio(
+                id=media_id,
+                content=audio_data,
+                mime_type="audio/wav",
             )
+
             log_debug(f"Successfully generated speech artifact with ID: {media_id}")
-            return f"Speech generated successfully with ID: {media_id}"
+            return ToolResult(content=f"Speech generated successfully with ID: {media_id}", audios=[audio_artifact])
 
         except Exception as e:
             log_error(f"Failed to generate speech with Groq: {str(e)}")
-            return f"Failed to generate speech with Groq: {str(e)}"
+            return ToolResult(content=f"Failed to generate speech with Groq: {str(e)}")

agno/tools/models/nebius.py

@@ -4,9 +4,10 @@ from typing import Optional
 from uuid import uuid4
 
 from agno.agent import Agent
-from agno.media import ImageArtifact
+from agno.media import Image
 from agno.models.nebius import Nebius
 from agno.tools import Toolkit
+from agno.tools.function import ToolResult
 from agno.utils.log import log_error, log_warning
 
 
@@ -21,6 +22,8 @@ class NebiusTools(Toolkit):
         image_quality: Optional[str] = "standard",
         image_size: Optional[str] = "1024x1024",
         image_style: Optional[str] = None,
+        enable_generate_image: bool = True,
+        all: bool = False,
         **kwargs,
     ):
         """Initialize Nebius AI Studio text-to-image tools.
@@ -35,9 +38,15 @@ class NebiusTools(Toolkit):
             image_quality: Image quality. Options: "standard", "hd".
             image_size: Image size in format "WIDTHxHEIGHT". Max supported: 2000x2000.
             image_style: Optional style preset to apply.
+            enable_generate_image: Enable image generation functionality.
+            all: Enable all functions.
             **kwargs: Additional arguments to pass to Toolkit.
         """
-        super().__init__(name="nebius_tools", tools=[self.generate_image], **kwargs)
+        tools = []
+        if all or enable_generate_image:
+            tools.append(self.generate_image)
+
+        super().__init__(name="nebius_tools", tools=tools, **kwargs)
 
         self.api_key = api_key or getenv("NEBIUS_API_KEY")
         if not self.api_key:
@@ -59,7 +68,7 @@ class NebiusTools(Toolkit):
         self,
         agent: Agent,
         prompt: str,
-    ) -> str:
+    ) -> ToolResult:
         """Generate images based on a text prompt using Nebius AI Studio.
 
         Args:
@@ -67,7 +76,7 @@ class NebiusTools(Toolkit):
             prompt: The text prompt to generate images from.
 
         Returns:
-            A message indicating success or failure.
+            ToolResult: A ToolResult containing the generated image or error message.
         """
         try:
             extra_params = {
@@ -91,18 +100,25 @@ class NebiusTools(Toolkit):
                 data = response.data[0]
             if data is None:
                 log_warning("Nebius 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
                 image_content_bytes = base64.b64decode(image_base64)
                 media_id = str(uuid4())
-                agent.add_image(
-                    ImageArtifact(
-                        id=media_id, content=image_content_bytes, mime_type="image/png", original_prompt=prompt
-                    )
+
+                # Create ImageArtifact with raw bytes
+                image_artifact = Image(
+                    id=media_id, content=image_content_bytes, 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}")

agno/tools/models_labs.py

@@ -5,10 +5,11 @@ from typing import Any, Dict, List, Optional, Union
 from uuid import uuid4
 
 from agno.agent import Agent
-from agno.media import AudioArtifact, ImageArtifact, VideoArtifact
+from agno.media import Audio, Image, Video
 from agno.models.response import FileType
 from agno.team import Team
 from agno.tools import Toolkit
+from agno.tools.function import ToolResult
 from agno.utils.log import log_debug, log_info, logger
 
 try:
@@ -86,16 +87,25 @@ class ModelsLabTools(Toolkit):
 
         return base_payload
 
-    def _add_media_artifact(
-        self, agent: Union[Agent, Team], media_id: str, media_url: str, eta: Optional[str] = None
-    ) -> None:
-        """Add appropriate media artifact based on file type."""
+    def _create_media_artifacts(self, media_id: str, media_url: str, eta: Optional[str] = None) -> Dict[str, List]:
+        """Create appropriate media artifacts based on file type."""
+        artifacts: Dict[str, List[Union[Image, Video, Audio]]] = {
+            "images": [],
+            "videos": [],
+            "audios": [],
+        }
+
         if self.file_type == FileType.MP4:
-            agent.add_video(VideoArtifact(id=str(media_id), url=media_url, eta=str(eta)))
+            video_artifact = Video(id=str(media_id), url=media_url, eta=str(eta))
+            artifacts["videos"].append(video_artifact)
         elif self.file_type == FileType.GIF:
-            agent.add_image(ImageArtifact(id=str(media_id), url=media_url))
+            image_artifact = Image(id=str(media_id), url=media_url)
+            artifacts["images"].append(image_artifact)
         elif self.file_type == FileType.MP3:
-            agent.add_audio(AudioArtifact(id=str(media_id), url=media_url))
+            audio_artifact = Audio(id=str(media_id), url=media_url)
+            artifacts["audios"].append(audio_artifact)
+
+        return artifacts
 
     def _wait_for_media(self, media_id: str, eta: int) -> bool:
         """Wait for media generation to complete."""
@@ -121,10 +131,10 @@ class ModelsLabTools(Toolkit):
 
         return False
 
-    def generate_media(self, agent: Union[Agent, Team], prompt: str) -> str:
+    def generate_media(self, agent: Union[Agent, Team], prompt: str) -> ToolResult:
         """Generate media (video, image, or audio) given a prompt."""
         if not self.api_key:
-            return "Please set the MODELS_LAB_API_KEY"
+            return ToolResult(content="Please set the MODELS_LAB_API_KEY")
 
         try:
             payload = json.dumps(self._create_payload(prompt))
@@ -139,19 +149,27 @@ class ModelsLabTools(Toolkit):
             status = result.get("status")
             if status == "error":
                 logger.error(f"Error in response: {result.get('message')}")
-                return f"Error: {result.get('message')}"
+                return ToolResult(content=f"Error: {result.get('message')}")
 
             if "error" in result:
                 error_msg = f"Failed to generate {self.file_type.value}: {result['error']}"
                 logger.error(error_msg)
-                return f"Error: {result['error']}"
+                return ToolResult(content=f"Error: {result['error']}")
 
             eta = result.get("eta")
             url_links = result.get("future_links")
             media_id = str(uuid4())
 
+            # Collect all media artifacts
+            all_images = []
+            all_videos = []
+            all_audios = []
+
             for media_url in url_links:
-                self._add_media_artifact(agent, media_id, media_url, str(eta))
+                artifacts = self._create_media_artifacts(media_id, media_url, str(eta))
+                all_images.extend(artifacts["images"])
+                all_videos.extend(artifacts["videos"])
+                all_audios.extend(artifacts["audios"])
 
             if self.wait_for_completion and isinstance(eta, int):
                 if self._wait_for_media(media_id, eta):
@@ -159,13 +177,19 @@ class ModelsLabTools(Toolkit):
                 else:
                     logger.warning("Media generation timed out")
 
-            return f"{self.file_type.value.capitalize()} has been generated successfully and will be ready in {eta} seconds"
+            # Return ToolResult with appropriate media artifacts
+            return ToolResult(
+                content=f"{self.file_type.value.capitalize()} has been generated successfully and will be ready in {eta} seconds",
+                images=all_images if all_images else None,
+                videos=all_videos if all_videos else None,
+                audios=all_audios if all_audios else None,
+            )
 
         except RequestException as e:
             error_msg = f"Network error while generating {self.file_type.value}: {e}"
             logger.error(error_msg)
-            return f"Error: {error_msg}"
+            return ToolResult(content=f"Error: {error_msg}")
         except Exception as e:
             error_msg = f"Unexpected error while generating {self.file_type.value}: {e}"
             logger.error(error_msg)
-            return f"Error: {error_msg}"
+            return ToolResult(content=f"Error: {error_msg}")

agno/tools/moviepy_video.py

@@ -14,17 +14,18 @@ class MoviePyVideoTools(Toolkit):
 
     def __init__(
         self,
-        process_video: bool = True,
-        generate_captions: bool = True,
-        embed_captions: bool = True,
+        enable_process_video: bool = True,
+        enable_generate_captions: bool = True,
+        enable_embed_captions: bool = True,
+        all: bool = False,
         **kwargs,
     ):
         tools: List[Any] = []
-        if process_video:
+        if enable_process_video or all:
             tools.append(self.extract_audio)
-        if generate_captions:
+        if enable_generate_captions or all:
             tools.append(self.create_srt)
-        if embed_captions:
+        if enable_embed_captions or all:
             tools.append(self.embed_captions)
 
         super().__init__(name="video_tools", tools=tools, **kwargs)

agno/tools/neo4j.py

@@ -17,10 +17,12 @@ class Neo4jTools(Toolkit):
         user: Optional[str] = None,
         password: Optional[str] = None,
         database: Optional[str] = None,
-        list_labels: bool = True,
-        list_relationships: bool = True,
-        get_schema: bool = True,
-        run_cypher: bool = True,
+        # 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,
     ):
         """
@@ -62,13 +64,13 @@ class Neo4jTools(Toolkit):
 
         # Register toolkit methods as tools
         tools: List[Any] = []
-        if list_labels:
+        if all or enable_list_labels:
             tools.append(self.list_labels)
-        if list_relationships:
+        if all or enable_list_relationships:
             tools.append(self.list_relationship_types)
-        if get_schema:
+        if all or enable_get_schema:
             tools.append(self.get_schema)
-        if run_cypher:
+        if all or enable_run_cypher:
             tools.append(self.run_cypher_query)
         super().__init__(name="neo4j_tools", tools=tools, **kwargs)
 

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

@@ -3,9 +3,10 @@ from typing import Any, List, Literal, Optional, Union
 from uuid import uuid4
 
 from agno.agent import Agent
-from agno.media import AudioArtifact, ImageArtifact
+from agno.media import Audio, Image
 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,36 +139,43 @@ 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 = Image(
+                    id=media_id,
+                    content=image_bytes,  # ← Store as bytes, not encoded string
+                    mime_type="image/png",
+                    original_prompt=prompt,
+                )
+
+                return ToolResult(
+                    content="Image generated successfully.",
+                    images=[image_artifact],
                 )
-                return "Image generated successfully."
-            return "Failed to generate image: No content received from API."
+
+            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.
         """
         try:
-            import base64
-
             response = OpenAIClient(api_key=self.api_key).audio.speech.create(
                 model=self.tts_model,
                 voice=self.tts_voice,
@@ -160,17 +186,17 @@ class OpenAITools(Toolkit):
             # Get raw audio data for artifact creation before potentially saving
             audio_data: bytes = response.content
 
-            # 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 = Audio(
+                id=media_id,
+                content=audio_data,
+                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.