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

agno/tools/linkup.py

@@ -16,6 +16,8 @@ class LinkupTools(Toolkit):
         api_key: Optional[str] = None,
         depth: Literal["standard", "deep"] = "standard",
         output_type: Literal["sourcedAnswer", "searchResults"] = "searchResults",
+        enable_web_search_with_linkup: bool = True,
+        all: bool = False,
         **kwargs,
     ):
         self.api_key = api_key or getenv("LINKUP_API_KEY")
@@ -26,7 +28,9 @@ class LinkupTools(Toolkit):
         self.depth = depth
         self.output_type = output_type
 
-        tools: List[Any] = [self.web_search_with_linkup]
+        tools: List[Any] = []
+        if all or enable_web_search_with_linkup:
+            tools.append(self.web_search_with_linkup)
 
         super().__init__(name="linkup_tools", tools=tools, **kwargs)
 

agno/tools/local_file_system.py

@@ -1,4 +1,3 @@
-import os
 from pathlib import Path
 from typing import Optional
 from uuid import uuid4
@@ -12,6 +11,8 @@ class LocalFileSystemTools(Toolkit):
         self,
         target_directory: Optional[str] = None,
         default_extension: str = "txt",
+        enable_write_file: bool = True,
+        all: bool = False,
         **kwargs,
     ):
         """
@@ -21,14 +22,15 @@ class LocalFileSystemTools(Toolkit):
             default_extension (str): Default file extension to use if none specified.
         """
 
-        self.target_directory = target_directory or os.getcwd()
+        self.target_directory = target_directory or str(Path.cwd())
         self.default_extension = default_extension.lstrip(".")
 
         target_path = Path(self.target_directory)
         target_path.mkdir(parents=True, exist_ok=True)
 
         tools = []
-        tools.append(self.write_file)
+        if all or enable_write_file:
+            tools.append(self.write_file)
 
         super().__init__(name="write_to_local", tools=tools, **kwargs)
 
@@ -53,8 +55,9 @@ class LocalFileSystemTools(Toolkit):
             filename = filename or str(uuid4())
             directory = directory or self.target_directory
             if filename and "." in filename:
-                filename, file_ext = os.path.splitext(filename)
-                extension = extension or file_ext.lstrip(".")
+                path_obj = Path(filename)
+                filename = path_obj.stem
+                extension = extension or path_obj.suffix.lstrip(".")
 
             log_debug(f"Writing file to local system: {filename}")
 

agno/tools/lumalab.py

@@ -4,8 +4,9 @@ from os import getenv
 from typing import Any, Dict, List, Literal, Optional, TypedDict
 
 from agno.agent import Agent
-from agno.media import VideoArtifact
+from agno.media import Video
 from agno.tools import Toolkit
+from agno.tools.function import ToolResult
 from agno.utils.log import log_info, logger
 
 try:
@@ -30,6 +31,9 @@ class LumaLabTools(Toolkit):
         wait_for_completion: bool = True,
         poll_interval: int = 3,
         max_wait_time: int = 300,  # 5 minutes
+        enable_generate_video: bool = True,
+        enable_image_to_video: bool = True,
+        all: bool = False,
         **kwargs,
     ):
         self.wait_for_completion = wait_for_completion
@@ -43,8 +47,10 @@ class LumaLabTools(Toolkit):
         self.client = LumaAI(auth_token=self.api_key)
 
         tools: List[Any] = []
-        tools.append(self.generate_video)
-        tools.append(self.image_to_video)
+        if all or enable_generate_video:
+            tools.append(self.generate_video)
+        if all or enable_image_to_video:
+            tools.append(self.image_to_video)
 
         super().__init__(name="luma_lab", tools=tools, **kwargs)
 
@@ -56,7 +62,7 @@ class LumaLabTools(Toolkit):
         end_image_url: Optional[str] = None,
         loop: bool = False,
         aspect_ratio: Literal["1:1", "16:9", "9:16", "4:3", "3:4", "21:9", "9:21"] = "16:9",
-    ) -> str:
+    ) -> ToolResult:
         """Generate a video from one or two images with a prompt.
 
         Args:
@@ -68,7 +74,7 @@ class LumaLabTools(Toolkit):
             aspect_ratio: Aspect ratio of the output video
 
         Returns:
-            str: Status message or error
+            ToolResult: A ToolResult containing the generated video or error message.
         """
 
         try:
@@ -90,33 +96,36 @@ class LumaLabTools(Toolkit):
             video_id = str(uuid.uuid4())
 
             if not self.wait_for_completion:
-                return "Async generation unsupported"
+                return ToolResult(content="Async generation unsupported")
 
             # Poll for completion
             seconds_waited = 0
             while seconds_waited < self.max_wait_time:
                 if not generation or not generation.id:
-                    return "Failed to get generation ID"
+                    return ToolResult(content="Failed to get generation ID")
 
                 generation = self.client.generations.get(generation.id)
 
                 if generation.state == "completed" and generation.assets:
                     video_url = generation.assets.video
                     if video_url:
-                        agent.add_video(VideoArtifact(id=video_id, url=video_url, eta="completed"))
-                        return f"Video generated successfully: {video_url}"
+                        video_artifact = Video(id=video_id, url=video_url, eta="completed")
+                        return ToolResult(
+                            content=f"Video generated successfully: {video_url}",
+                            videos=[video_artifact],
+                        )
                 elif generation.state == "failed":
-                    return f"Generation failed: {generation.failure_reason}"
+                    return ToolResult(content=f"Generation failed: {generation.failure_reason}")
 
                 log_info(f"Generation in progress... State: {generation.state}")
                 time.sleep(self.poll_interval)
                 seconds_waited += self.poll_interval
 
-            return f"Video generation timed out after {self.max_wait_time} seconds"
+            return ToolResult(content=f"Video generation timed out after {self.max_wait_time} seconds")
 
         except Exception as e:
             logger.error(f"Failed to generate video: {e}")
-            return f"Error: {e}"
+            return ToolResult(content=f"Error: {e}")
 
     def generate_video(
         self,
@@ -125,7 +134,7 @@ class LumaLabTools(Toolkit):
         loop: bool = False,
         aspect_ratio: Literal["1:1", "16:9", "9:16", "4:3", "3:4", "21:9", "9:21"] = "16:9",
         keyframes: Optional[Dict[str, Dict[str, str]]] = None,
-    ) -> str:
+    ) -> ToolResult:
         """Use this function to generate a video given a prompt."""
 
         try:
@@ -142,30 +151,33 @@ class LumaLabTools(Toolkit):
 
             video_id = str(uuid.uuid4())
             if not self.wait_for_completion:
-                return "Async generation unsupported"
+                return ToolResult(content="Async generation unsupported")
 
             # Poll for completion
             seconds_waited = 0
             while seconds_waited < self.max_wait_time:
                 if not generation or not generation.id:
-                    return "Failed to get generation ID"
+                    return ToolResult(content="Failed to get generation ID")
 
                 generation = self.client.generations.get(generation.id)
 
                 if generation.state == "completed" and generation.assets:
                     video_url = generation.assets.video
                     if video_url:
-                        agent.add_video(VideoArtifact(id=video_id, url=video_url, state="completed"))
-                        return f"Video generated successfully: {video_url}"
+                        video_artifact = Video(id=video_id, url=video_url, state="completed")
+                        return ToolResult(
+                            content=f"Video generated successfully: {video_url}",
+                            videos=[video_artifact],
+                        )
                 elif generation.state == "failed":
-                    return f"Generation failed: {generation.failure_reason}"
+                    return ToolResult(content=f"Generation failed: {generation.failure_reason}")
 
                 log_info(f"Generation in progress... State: {generation.state}")
                 time.sleep(self.poll_interval)
                 seconds_waited += self.poll_interval
 
-            return f"Video generation timed out after {self.max_wait_time} seconds"
+            return ToolResult(content=f"Video generation timed out after {self.max_wait_time} seconds")
 
         except Exception as e:
             logger.error(f"Failed to generate video: {e}")
-            return f"Error: {e}"
+            return ToolResult(content=f"Error: {e}")

agno/tools/mcp.py

@@ -365,7 +365,7 @@ class MultiMCPTools(Toolkit):
         *,
         env: Optional[dict[str, str]] = None,
         server_params_list: Optional[
-            List[Union[SSEClientParams, StdioServerParameters, StreamableHTTPClientParams]]
+            list[Union[SSEClientParams, StdioServerParameters, StreamableHTTPClientParams]]
         ] = None,
         timeout_seconds: int = 5,
         client=None,
@@ -531,7 +531,6 @@ class MultiMCPTools(Toolkit):
                 session = await self._async_exit_stack.enter_async_context(ClientSession(read, write))
                 self._active_contexts.append(session)
                 await self.initialize(session)
-
             # Handle Streamable HTTP connections
             elif isinstance(server_params, StreamableHTTPClientParams):
                 client_connection = await self._async_exit_stack.enter_async_context(

agno/tools/mem0.py

@@ -1,9 +1,9 @@
 import json
 from os import getenv
-from typing import Any, Dict, Optional, Union
+from typing import Any, Dict, List, Optional, Union
 
 from agno.agent import Agent
-from agno.tools.toolkit import Toolkit
+from agno.tools import Toolkit
 from agno.utils.log import log_debug, log_error, log_warning
 
 try:
@@ -22,18 +22,24 @@ class Mem0Tools(Toolkit):
         org_id: Optional[str] = None,
         project_id: Optional[str] = None,
         infer: bool = True,
+        enable_add_memory: bool = True,
+        enable_search_memory: bool = True,
+        enable_get_all_memories: bool = True,
+        enable_delete_all_memories: bool = True,
+        all: bool = False,
         **kwargs,
     ):
-        super().__init__(
-            name="mem0_tools",
-            tools=[
-                self.add_memory,
-                self.search_memory,
-                self.get_all_memories,
-                self.delete_all_memories,
-            ],
-            **kwargs,
-        )
+        tools: List[Any] = []
+        if enable_add_memory or all:
+            tools.append(self.add_memory)
+        if enable_search_memory or all:
+            tools.append(self.search_memory)
+        if enable_get_all_memories or all:
+            tools.append(self.get_all_memories)
+        if enable_delete_all_memories or all:
+            tools.append(self.delete_all_memories)
+
+        super().__init__(name="mem0_tools", tools=tools, **kwargs)
         self.api_key = api_key or getenv("MEM0_API_KEY")
         self.user_id = user_id
         self.org_id = org_id or getenv("MEM0_ORG_ID")

agno/tools/memori.py

@@ -1,5 +1,5 @@
 import json
-from typing import Any, Dict, Optional
+from typing import Any, Dict, List, Optional
 
 from agno.agent import Agent
 from agno.tools.toolkit import Toolkit
@@ -54,6 +54,10 @@ class MemoriTools(Toolkit):
         verbose: bool = False,
         config: Optional[Dict[str, Any]] = None,
         auto_enable: bool = True,
+        enable_search_memory: bool = True,
+        enable_record_conversation: bool = True,
+        enable_get_memory_stats: bool = True,
+        all: bool = False,
         **kwargs,
     ):
         """
@@ -69,15 +73,15 @@ class MemoriTools(Toolkit):
             auto_enable: Automatically enable the memory system on initialization
             **kwargs: Additional arguments passed to Toolkit base class
         """
-        super().__init__(
-            name="memori_tools",
-            tools=[
-                self.search_memory,
-                self.record_conversation,
-                self.get_memory_stats,
-            ],
-            **kwargs,
-        )
+        tools: List[Any] = []
+        if all or enable_search_memory:
+            tools.append(self.search_memory)
+        if all or enable_record_conversation:
+            tools.append(self.record_conversation)
+        if all or enable_get_memory_stats:
+            tools.append(self.get_memory_stats)
+
+        super().__init__(name="memori_tools", tools=tools, **kwargs)
 
         # Set default database connection if not provided
         if not database_connect:

agno/tools/mlx_transcribe.py

@@ -32,7 +32,7 @@ class MLXTranscribeTools(Toolkit):
     def __init__(
         self,
         base_dir: Optional[Path] = None,
-        read_files_in_base_dir: bool = True,
+        enable_read_files_in_base_dir: bool = True,
         path_or_hf_repo: str = "mlx-community/whisper-large-v3-turbo",
         verbose: Optional[bool] = None,
         temperature: Optional[Union[float, Tuple[float, ...]]] = None,
@@ -47,6 +47,7 @@ class MLXTranscribeTools(Toolkit):
         clip_timestamps: Optional[Union[str, List[float]]] = None,
         hallucination_silence_threshold: Optional[float] = None,
         decode_options: Optional[dict] = None,
+        all: bool = False,
         **kwargs,
     ):
         self.base_dir: Path = base_dir or Path.cwd()
@@ -66,7 +67,7 @@ class MLXTranscribeTools(Toolkit):
         self.decode_options: Optional[dict] = decode_options
 
         tools: List[Any] = [self.transcribe]
-        if read_files_in_base_dir:
+        if enable_read_files_in_base_dir or all:
             tools.append(self.read_files)
 
         super().__init__(name="mlx_transcribe", tools=tools, **kwargs)

agno/tools/models/azure_openai.py

@@ -5,8 +5,9 @@ from uuid import uuid4
 from requests import post
 
 from agno.agent import Agent
-from agno.media import ImageArtifact
+from agno.media import Image
 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 = Image(
+                    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

@@ -5,8 +5,9 @@ from typing import Any, Optional
 from uuid import uuid4
 
 from agno.agent import Agent
-from agno.media import ImageArtifact, VideoArtifact
+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:
@@ -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 = Image(
+                    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 = Video(
+                    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}")