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

agno/tools/models/azure_openai.py

@@ -7,6 +7,7 @@ from requests import post
 from agno.agent import Agent
 from agno.media import ImageArtifact
 from agno.tools import Toolkit
+from agno.tools.function import ToolResult
 from agno.utils.log import log_debug, logger
 
 
@@ -31,9 +32,9 @@ class AzureOpenAITools(Toolkit):
         image_deployment: Optional[str] = None,
         image_model: str = "dall-e-3",
         image_quality: Literal["standard", "hd"] = "standard",  # Note: "hd" quality is only available for dall-e-3.
+        enable_generate_image: bool = True,
+        all: bool = False,
     ):
-        super().__init__(name="azure_openai")
-
         # Set credentials from parameters or environment variables
         self.api_key = api_key or getenv("AZURE_OPENAI_API_KEY")
         self.azure_endpoint = azure_endpoint or getenv("AZURE_OPENAI_ENDPOINT")
@@ -49,15 +50,20 @@ class AzureOpenAITools(Toolkit):
         self.image_deployment = image_deployment or getenv("AZURE_OPENAI_IMAGE_DEPLOYMENT")
         self.image_model = image_model
 
+        # Build tools list based on available services
+        tools = []
+
         # Validate image generation parameters
         if self.image_deployment and self.image_model in self.VALID_MODELS:
             # Create and store the base URL
             self.image_base_url = f"{self.azure_endpoint}/openai/deployments/{self.image_deployment}/images/generations?api-version={self.api_version}"
-            # Register the image generation tool
-            self.register(self.generate_image)
+            if all or enable_generate_image:
+                tools.append(self.generate_image)
         else:
             logger.error("Missing required image generation parameters or invalid model")
 
+        super().__init__(name="azure_openai_tools", tools=tools)
+
         self.image_quality = image_quality
 
         # Validate quality
@@ -98,7 +104,7 @@ class AzureOpenAITools(Toolkit):
         n: int = 1,
         size: Optional[Literal["256x256", "512x512", "1024x1024", "1792x1024", "1024x1792"]] = "1024x1024",
         style: Literal["vivid", "natural"] = "vivid",
-    ) -> str:
+    ) -> ToolResult:
         """Generate an image using Azure OpenAI image generation.
 
         Args:
@@ -114,7 +120,7 @@ class AzureOpenAITools(Toolkit):
                 Note: "vivid" produces more dramatic images, while "natural" produces more realistic ones.
 
         Returns:
-            A message with image URLs or an error message
+            ToolResult: A ToolResult containing the generated images or error message.
 
         Note:
             Invalid parameters will be automatically corrected to valid values. For example:
@@ -125,7 +131,9 @@ class AzureOpenAITools(Toolkit):
         """
         # Check if image generation is properly initialized
         if not hasattr(self, "image_base_url"):
-            return "Image generation tool not properly initialized. Please check your configuration."
+            return ToolResult(
+                content="Image generation tool not properly initialized. Please check your configuration."
+            )
 
         # Enforce valid parameters
         params = self._enforce_valid_image_parameters(
@@ -147,26 +155,36 @@ class AzureOpenAITools(Toolkit):
             response = post(self.image_base_url, headers=headers, json=params)
 
             if response.status_code != 200:
-                return f"Error {response.status_code}: {response.text}"
+                return ToolResult(content=f"Error {response.status_code}: {response.text}")
 
             # Process results
             data = response.json()
             log_debug("Image generated successfully")
 
-            # Add images to agent
+            # Create ImageArtifact objects for generated images
+            generated_images = []
             response_str = ""
+
             for img in data.get("data", []):
                 image_url = img.get("url")
                 revised_prompt = img.get("revised_prompt")
 
-                # Add image to agent
-                agent.add_image(
-                    ImageArtifact(id=str(uuid4()), url=image_url, original_prompt=prompt, revised_prompt=revised_prompt)
+                # Create ImageArtifact with URL
+                image_artifact = ImageArtifact(
+                    id=str(uuid4()), url=image_url, original_prompt=prompt, revised_prompt=revised_prompt
                 )
+                generated_images.append(image_artifact)
 
                 response_str += f"Image has been generated at the URL {image_url}\n"
-            return response_str
+
+            if generated_images:
+                return ToolResult(
+                    content=response_str.strip(),
+                    images=generated_images,
+                )
+            else:
+                return ToolResult(content="No images were generated.")
 
         except Exception as e:
             logger.error(f"Failed to generate image: {e}")
-            return f"Error: {e}"
+            return ToolResult(content=f"Error: {e}")

agno/tools/models/gemini.py

@@ -7,6 +7,7 @@ from uuid import uuid4
 from agno.agent import Agent
 from agno.media import ImageArtifact, VideoArtifact
 from agno.tools import Toolkit
+from agno.tools.function import ToolResult
 from agno.utils.log import log_debug, log_error, log_info
 
 try:
@@ -27,9 +28,18 @@ class GeminiTools(Toolkit):
         location: Optional[str] = None,
         image_generation_model: str = "imagen-3.0-generate-002",
         video_generation_model: str = "veo-2.0-generate-001",
+        enable_generate_image: bool = True,
+        enable_generate_video: bool = True,
+        all: bool = False,
         **kwargs,
     ):
-        super().__init__(name="gemini_tools", tools=[self.generate_image, self.generate_video], **kwargs)
+        tools = []
+        if all or enable_generate_image:
+            tools.append(self.generate_image)
+        if all or enable_generate_video:
+            tools.append(self.generate_video)
+
+        super().__init__(name="gemini_tools", tools=tools, **kwargs)
 
         # Set mode and credentials: use only provided vertexai parameter
         self.vertexai = vertexai or getenv("GOOGLE_GENAI_USE_VERTEXAI") == "true"
@@ -67,13 +77,13 @@ class GeminiTools(Toolkit):
         self,
         agent: Agent,
         prompt: str,
-    ) -> str:
+    ) -> ToolResult:
         """Generate images based on a text prompt using Google Imagen.
 
         Args:
             prompt (str): The text prompt to generate the image from.
         Returns:
-            str: A message indicating success (including media ID) or failure.
+            ToolResult: A ToolResult containing the generated images or error message.
         """
 
         try:
@@ -87,47 +97,55 @@ class GeminiTools(Toolkit):
             # Extract image bytes
             if response.generated_images is None or not response.generated_images:
                 log_info("No images were generated.")
-                return "Failed to generate image: No images were generated."
+                return ToolResult(content="Failed to generate image: No images were generated.")
 
+            generated_images = []
             for generated_image in response.generated_images:
                 if generated_image.image is None or not generated_image.image.image_bytes:
                     continue
+
                 image_bytes = generated_image.image.image_bytes
-                base64_encoded_image_bytes = base64.b64encode(image_bytes)
                 actual_mime_type = "image/png"
-
                 media_id = str(uuid4())
-                agent.add_image(
-                    ImageArtifact(
-                        id=media_id,
-                        content=base64_encoded_image_bytes,
-                        original_prompt=prompt,
-                        mime_type=actual_mime_type,
-                    )
+
+                # Create ImageArtifact with raw bytes (not base64 encoded)
+                image_artifact = ImageArtifact(
+                    id=media_id,
+                    content=image_bytes,
+                    original_prompt=prompt,
+                    mime_type=actual_mime_type,
                 )
+                generated_images.append(image_artifact)
                 log_debug(f"Successfully generated image {media_id} with model {self.image_model}")
-            return "Image generated successfully"
+
+            if generated_images:
+                return ToolResult(
+                    content="Image generated successfully",
+                    images=generated_images,
+                )
+            else:
+                return ToolResult(content="Failed to generate image: No valid images were generated.")
 
         except Exception as e:
             log_error(f"Failed to generate image: Client or method not available ({e})")
-            return f"Failed to generate image: Client or method not available ({e})"
+            return ToolResult(content=f"Failed to generate image: Client or method not available ({e})")
 
     def generate_video(
         self,
         agent: Agent,
         prompt: str,
-    ) -> str:
+    ) -> ToolResult:
         """Generate a video based on a text prompt.
         Args:
             prompt (str): The text prompt to generate the video from.
         Returns:
-            str: A message indicating success or failure.
+            ToolResult: A ToolResult containing the generated video or error message.
         """
         # Video generation requires Vertex AI mode.
         if not self.vertexai:
             log_error("Video generation requires Vertex AI mode. Please enable Vertex AI mode.")
-            return (
-                "Video generation requires Vertex AI mode. "
+            return ToolResult(
+                content="Video generation requires Vertex AI mode. "
                 "Please set `vertexai=True` or environment variable `GOOGLE_GENAI_USE_VERTEXAI=true`."
             )
 
@@ -149,28 +167,37 @@ class GeminiTools(Toolkit):
             result = operation.result
             if result is None or result.generated_videos is None or not result.generated_videos:
                 log_error("No videos were generated.")
-                return "Failed to generate video: No videos were generated."
+                return ToolResult(content="Failed to generate video: No videos were generated.")
 
+            generated_videos = []
             for video in result.generated_videos:
                 if video.video is None or not video.video.video_bytes:
                     continue
+
                 generated_video = video.video
                 if generated_video.video_bytes is None:
                     continue
 
                 media_id = str(uuid4())
-                encoded_video = base64.b64encode(generated_video.video_bytes).decode("utf-8")
-
-                agent.add_video(
-                    VideoArtifact(
-                        id=media_id,
-                        content=encoded_video,
-                        original_prompt=prompt,
-                        mime_type=generated_video.mime_type or "video/mp4",
-                    )
+
+                # Create VideoArtifact with base64 encoded content
+                video_artifact = VideoArtifact(
+                    id=media_id,
+                    content=base64.b64encode(generated_video.video_bytes).decode("utf-8"),
+                    original_prompt=prompt,
+                    mime_type=generated_video.mime_type or "video/mp4",
                 )
+                generated_videos.append(video_artifact)
                 log_debug(f"Successfully generated video {media_id} with model {self.video_model}")
-            return "Video generated successfully"
+
+            if generated_videos:
+                return ToolResult(
+                    content="Video generated successfully",
+                    videos=generated_videos,
+                )
+            else:
+                return ToolResult(content="Failed to generate video: No valid videos were generated.")
+
         except Exception as e:
             log_error(f"Failed to generate video: {e}")
-            return f"Failed to generate video: {e}"
+            return ToolResult(content=f"Failed to generate video: {e}")

agno/tools/models/groq.py

@@ -1,12 +1,13 @@
 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.tools import Toolkit
+from agno.tools.function import ToolResult
 from agno.utils.log import log_debug, log_error
 
 try:
@@ -25,11 +26,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 +63,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 +74,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 +94,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 +105,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 +120,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}"
@@ -136,16 +146,15 @@ class GroqTools(Toolkit):
             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 = AudioArtifact(
+                id=media_id,
+                base64_audio=base64_encoded_audio,
+                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

@@ -7,6 +7,7 @@ from agno.agent import Agent
 from agno.media import ImageArtifact
 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 = ImageArtifact(
+                    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

@@ -9,6 +9,7 @@ from agno.media import AudioArtifact, ImageArtifact, VideoArtifact
 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[ImageArtifact, VideoArtifact, AudioArtifact]]] = {
+            "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 = VideoArtifact(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 = ImageArtifact(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 = AudioArtifact(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)