agno 2.0.0rc2__py3-none-any.whl → 2.3.0__py3-none-any.whl

agno/tools/models/nebius.py

@@ -4,7 +4,7 @@ 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
@@ -12,12 +12,12 @@ from agno.utils.log import log_error, log_warning
 
 
 class NebiusTools(Toolkit):
-    """Tools for interacting with Nebius AI Studio's text-to-image API"""
+    """Tools for interacting with Nebius Token Factory's text-to-image API"""
 
     def __init__(
         self,
         api_key: Optional[str] = None,
-        base_url: str = "https://api.studio.nebius.com/v1",
+        base_url: str = "https://api.tokenfactory.nebius.com/v1",
         image_model: str = "black-forest-labs/flux-schnell",
         image_quality: Optional[str] = "standard",
         image_size: Optional[str] = "1024x1024",
@@ -26,11 +26,11 @@ class NebiusTools(Toolkit):
         all: bool = False,
         **kwargs,
     ):
-        """Initialize Nebius AI Studio text-to-image tools.
+        """Initialize Nebius Token Factory text-to-image tools.
 
         Args:
             api_key: Nebius API key. If not provided, will look for NEBIUS_API_KEY environment variable.
-            base_url: The base URL for the Nebius AI Studio API. This should be configured according to Nebius's documentation.
+            base_url: The base URL for the Nebius Token Factory API. This should be configured according to Nebius's documentation.
             image_model: The model to use for generation. Options include:
                   - "black-forest-labs/flux-schnell" (fastest)
                   - "black-forest-labs/flux-dev" (balanced)
@@ -69,7 +69,7 @@ class NebiusTools(Toolkit):
         agent: Agent,
         prompt: str,
     ) -> ToolResult:
-        """Generate images based on a text prompt using Nebius AI Studio.
+        """Generate images based on a text prompt using Nebius Token Factory.
 
         Args:
             agent: The agent instance for adding images
@@ -108,7 +108,7 @@ class NebiusTools(Toolkit):
                 media_id = str(uuid4())
 
                 # Create ImageArtifact with raw bytes
-                image_artifact = ImageArtifact(
+                image_artifact = Image(
                     id=media_id, content=image_content_bytes, mime_type="image/png", original_prompt=prompt
                 )
 

agno/tools/models_labs.py

@@ -4,10 +4,8 @@ from os import getenv
 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
@@ -22,12 +20,14 @@ MODELS_LAB_URLS = {
     "MP4": "https://modelslab.com/api/v6/video/text2video",
     "MP3": "https://modelslab.com/api/v6/voice/music_gen",
     "GIF": "https://modelslab.com/api/v6/video/text2video",
+    "WAV": "https://modelslab.com/api/v6/voice/sfx",
 }
 
 MODELS_LAB_FETCH_URLS = {
     "MP4": "https://modelslab.com/api/v6/video/fetch",
     "MP3": "https://modelslab.com/api/v6/voice/fetch",
     "GIF": "https://modelslab.com/api/v6/video/fetch",
+    "WAV": "https://modelslab.com/api/v6/voice/fetch",
 }
 
 
@@ -78,6 +78,13 @@ class ModelsLabTools(Toolkit):
                 "output_type": self.file_type.value,
             }
             base_payload |= video_template  # Use |= instead of update()
+        elif self.file_type == FileType.WAV:
+            sfx_template = {
+                "duration": 10,
+                "output_format": "wav",
+                "temp": False,
+            }
+            base_payload |= sfx_template  # Use |= instead of update()
         else:
             audio_template = {
                 "base64": False,
@@ -89,20 +96,20 @@ class ModelsLabTools(Toolkit):
 
     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]]] = {
+        artifacts: Dict[str, List[Union[Image, Video, Audio]]] = {
             "images": [],
             "videos": [],
             "audios": [],
         }
 
         if self.file_type == FileType.MP4:
-            video_artifact = 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:
-            image_artifact = 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:
-            audio_artifact = AudioArtifact(id=str(media_id), url=media_url)
+        elif self.file_type in [FileType.MP3, FileType.WAV]:
+            audio_artifact = Audio(id=str(media_id), url=media_url)
             artifacts["audios"].append(audio_artifact)
 
         return artifacts
@@ -131,7 +138,7 @@ class ModelsLabTools(Toolkit):
 
         return False
 
-    def generate_media(self, agent: Union[Agent, Team], prompt: str) -> ToolResult:
+    def generate_media(self, prompt: str) -> ToolResult:
         """Generate media (video, image, or audio) given a prompt."""
         if not self.api_key:
             return ToolResult(content="Please set the MODELS_LAB_API_KEY")
@@ -157,7 +164,6 @@ class ModelsLabTools(Toolkit):
                 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
@@ -165,17 +171,21 @@ class ModelsLabTools(Toolkit):
             all_videos = []
             all_audios = []
 
+            if self.file_type == FileType.WAV:
+                url_links = result.get("output", [])
+            else:
+                url_links = result.get("future_links")
             for media_url in url_links:
                 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):
-                    log_info("Media generation completed successfully")
-                else:
-                    logger.warning("Media generation timed out")
+                if self.wait_for_completion and isinstance(eta, int):
+                    if self._wait_for_media(media_id, eta):
+                        log_info("Media generation completed successfully")
+                    else:
+                        logger.warning("Media generation timed out")
 
             # Return ToolResult with appropriate media artifacts
             return ToolResult(

agno/tools/notion.py

@@ -0,0 +1,204 @@
+import json
+import os
+from typing import Any, Dict, List, Optional, cast
+
+from agno.tools import Toolkit
+from agno.utils.log import log_debug, logger
+
+try:
+    from notion_client import Client
+except ImportError:
+    raise ImportError("`notion-client` not installed. Please install using `pip install notion-client`")
+
+
+class NotionTools(Toolkit):
+    """
+    Notion toolkit for creating and managing Notion pages.
+
+    Args:
+        api_key (Optional[str]): Notion API key (integration token). If not provided, uses NOTION_API_KEY env var.
+        database_id (Optional[str]): The ID of the database to work with. If not provided, uses NOTION_DATABASE_ID env var.
+        enable_create_page (bool): Enable creating pages. Default is True.
+        enable_update_page (bool): Enable updating pages. Default is True.
+        enable_search_pages (bool): Enable searching pages. Default is True.
+        all (bool): Enable all tools. Overrides individual flags when True. Default is False.
+    """
+
+    def __init__(
+        self,
+        api_key: Optional[str] = None,
+        database_id: Optional[str] = None,
+        enable_create_page: bool = True,
+        enable_update_page: bool = True,
+        enable_search_pages: bool = True,
+        all: bool = False,
+        **kwargs,
+    ):
+        self.api_key = api_key or os.getenv("NOTION_API_KEY")
+        self.database_id = database_id or os.getenv("NOTION_DATABASE_ID")
+
+        if not self.api_key:
+            raise ValueError(
+                "Notion API key is required. Either pass api_key parameter or set NOTION_API_KEY environment variable."
+            )
+        if not self.database_id:
+            raise ValueError(
+                "Notion database ID is required. Either pass database_id parameter or set NOTION_DATABASE_ID environment variable."
+            )
+
+        self.client = Client(auth=self.api_key)
+
+        tools: List[Any] = []
+        if all or enable_create_page:
+            tools.append(self.create_page)
+        if all or enable_update_page:
+            tools.append(self.update_page)
+        if all or enable_search_pages:
+            tools.append(self.search_pages)
+
+        super().__init__(name="notion_tools", tools=tools, **kwargs)
+
+    def create_page(self, title: str, tag: str, content: str) -> str:
+        """Create a new page in the Notion database with a title, tag, and content.
+
+        Args:
+            title (str): The title of the page
+            tag (str): The tag/category for the page (e.g., travel, tech, general-blogs, fashion, documents)
+            content (str): The content to add to the page
+
+        Returns:
+            str: JSON string with page creation details
+        """
+        try:
+            log_debug(f"Creating Notion page with title: {title}, tag: {tag}")
+
+            # Create the page in the database
+            new_page = cast(
+                Dict[str, Any],
+                self.client.pages.create(
+                    parent={"database_id": self.database_id},
+                    properties={"Name": {"title": [{"text": {"content": title}}]}, "Tag": {"select": {"name": tag}}},
+                    children=[
+                        {
+                            "object": "block",
+                            "type": "paragraph",
+                            "paragraph": {"rich_text": [{"type": "text", "text": {"content": content}}]},
+                        }
+                    ],
+                ),
+            )
+
+            result = {"success": True, "page_id": new_page["id"], "url": new_page["url"], "title": title, "tag": tag}
+            return json.dumps(result, indent=2)
+
+        except Exception as e:
+            logger.exception(e)
+            return json.dumps({"success": False, "error": str(e)})
+
+    def update_page(self, page_id: str, content: str) -> str:
+        """Add content to an existing Notion page.
+
+        Args:
+            page_id (str): The ID of the page to update
+            content (str): The content to append to the page
+
+        Returns:
+            str: JSON string with update status
+        """
+        try:
+            log_debug(f"Updating Notion page: {page_id}")
+
+            # Append content to the page
+            self.client.blocks.children.append(
+                block_id=page_id,
+                children=[
+                    {
+                        "object": "block",
+                        "type": "paragraph",
+                        "paragraph": {"rich_text": [{"type": "text", "text": {"content": content}}]},
+                    }
+                ],
+            )
+
+            result = {"success": True, "page_id": page_id, "message": "Content added successfully"}
+            return json.dumps(result, indent=2)
+
+        except Exception as e:
+            logger.exception(e)
+            return json.dumps({"success": False, "error": str(e)})
+
+    def search_pages(self, tag: str) -> str:
+        """Search for pages in the database by tag.
+
+        Args:
+            tag (str): The tag to search for
+
+        Returns:
+            str: JSON string with list of matching pages
+        """
+        try:
+            log_debug(f"Searching for pages with tag: {tag}")
+
+            import httpx
+
+            headers = {
+                "Authorization": f"Bearer {self.api_key}",
+                "Notion-Version": "2022-06-28",
+                "Content-Type": "application/json",
+            }
+
+            payload = {"filter": {"property": "Tag", "select": {"equals": tag}}}
+
+            # The SDK client does not support the query method
+            response = httpx.post(
+                f"https://api.notion.com/v1/databases/{self.database_id}/query",
+                headers=headers,
+                json=payload,
+                timeout=30.0,
+            )
+
+            if response.status_code != 200:
+                return json.dumps(
+                    {
+                        "success": False,
+                        "error": f"API request failed with status {response.status_code}",
+                        "message": response.text,
+                    }
+                )
+
+            data = response.json()
+            pages = []
+
+            for page in data.get("results", []):
+                try:
+                    page_title = "Untitled"
+                    if page.get("properties", {}).get("Name", {}).get("title"):
+                        page_title = page["properties"]["Name"]["title"][0]["text"]["content"]
+
+                    page_tag = None
+                    if page.get("properties", {}).get("Tag", {}).get("select"):
+                        page_tag = page["properties"]["Tag"]["select"]["name"]
+
+                    page_info = {
+                        "page_id": page["id"],
+                        "title": page_title,
+                        "tag": page_tag,
+                        "url": page.get("url", ""),
+                    }
+                    pages.append(page_info)
+                except Exception as page_error:
+                    log_debug(f"Error parsing page: {page_error}")
+                    continue
+
+            result = {"success": True, "count": len(pages), "pages": pages}
+            return json.dumps(result, indent=2)
+
+        except Exception as e:
+            logger.exception(e)
+            return json.dumps(
+                {
+                    "success": False,
+                    "error": str(e),
+                    "message": "Failed to search pages. Make sure the database is shared with the integration and has a 'Tag' property.",
+                }
+            )

agno/tools/openai.py

@@ -3,7 +3,7 @@ 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
@@ -149,7 +149,7 @@ class OpenAITools(Toolkit):
                 image_bytes = base64.b64decode(image_base64)
 
                 # Create ImageArtifact and return in ToolResult
-                image_artifact = ImageArtifact(
+                image_artifact = Image(
                     id=media_id,
                     content=image_bytes,  # ← Store as bytes, not encoded string
                     mime_type="image/png",
@@ -176,8 +176,6 @@ class OpenAITools(Toolkit):
             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,
@@ -188,14 +186,11 @@ 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 AudioArtifact and return in ToolResult
             media_id = str(uuid4())
-            audio_artifact = AudioArtifact(
+            audio_artifact = Audio(
                 id=media_id,
-                base64_audio=base64_encoded_audio,
+                content=audio_data,
                 mime_type=f"audio/{self.tts_format}",
             )
 

agno/tools/opencv.py

@@ -4,7 +4,7 @@ from typing import Callable, List
 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
@@ -120,7 +120,7 @@ class OpenCVTools(Toolkit):
                 media_id = str(uuid4())
 
                 # Create ImageArtifact with raw bytes (not base64 encoded)
-                image_artifact = ImageArtifact(
+                image_artifact = Image(
                     id=media_id,
                     content=image_bytes,  # Store as raw bytes
                     original_prompt=prompt,
@@ -292,7 +292,7 @@ class OpenCVTools(Toolkit):
                 media_id = str(uuid4())
 
                 # Create VideoArtifact with base64 encoded content
-                video_artifact = VideoArtifact(
+                video_artifact = Video(
                     id=media_id,
                     content=video_bytes,
                     original_prompt=prompt,