agno 0.1.2__py3-none-any.whl → 2.3.13__py3-none-any.whl

agno/tools/models/morph.py

@@ -0,0 +1,186 @@
+import os
+from os import getenv
+from textwrap import dedent
+from typing import Optional
+
+from agno.tools import Toolkit
+from agno.utils.log import log_debug, log_error
+
+try:
+    from openai import OpenAI
+except ImportError:
+    raise ImportError("`openai` not installed. Please install using `pip install openai`")
+
+
+class MorphTools(Toolkit):
+    """Tools for interacting with Morph's Fast Apply API for code editing"""
+
+    def __init__(
+        self,
+        api_key: Optional[str] = None,
+        base_url: str = "https://api.morphllm.com/v1",
+        instructions: Optional[str] = None,
+        add_instructions: bool = True,
+        model: str = "morph-v3-large",
+        **kwargs,
+    ):
+        """Initialize Morph Fast Apply tools.
+
+        Args:
+            api_key: Morph API key. If not provided, will look for MORPH_API_KEY environment variable.
+            base_url: The base URL for the Morph API.
+            model: The Morph model to use. Options:
+                  - "morph-v3-fast" (4500+ tok/sec, 96% accuracy)
+                  - "morph-v3-large" (2500+ tok/sec, 98% accuracy)
+                  - "auto" (automatic selection)
+            **kwargs: Additional arguments to pass to Toolkit.
+        """
+        # Set up instructions
+        if instructions is None:
+            self.instructions = self.DEFAULT_INSTRUCTIONS
+        else:
+            self.instructions = instructions
+
+        super().__init__(
+            name="morph_tools",
+            tools=[self.edit_file],
+            instructions=self.instructions,
+            add_instructions=add_instructions,
+            **kwargs,
+        )
+
+        self.api_key = api_key or getenv("MORPH_API_KEY")
+        if not self.api_key:
+            raise ValueError("MORPH_API_KEY not set. Please set the MORPH_API_KEY environment variable.")
+
+        self.base_url = base_url
+        self.model = model
+        self._morph_client: Optional[OpenAI] = None
+
+    def _get_client(self):
+        """Get or create the Morph OpenAI client."""
+        if self._morph_client is None:
+            self._morph_client = OpenAI(
+                api_key=self.api_key,
+                base_url=self.base_url,
+            )
+        return self._morph_client
+
+    def edit_file(
+        self,
+        target_file: str,
+        instructions: str,
+        code_edit: str,
+        original_code: Optional[str] = None,
+    ) -> str:
+        """
+        Apply code edits to a target file using Morph's Fast Apply API.
+
+        This function reads the specified file, sends its content along with
+        editing instructions and code edits to Morph's API, and writes the
+        resulting code back to the file. A backup of the original file is
+        created before writing changes.
+
+        Args:
+            target_file (str): Path to the file to be edited.
+            instructions (str): High-level instructions describing the intended change.
+            code_edit (str): Specific code edit or change to apply.
+            original_code (Optional[str], optional): Original content of the file.
+                If not provided, the function reads from target_file.
+
+        Returns:
+            str: Result message indicating success or failure, and details about
+                the backup and any errors encountered.
+        """
+        try:
+            # Always read the actual file content for backup purposes
+            actual_file_content = None
+            if os.path.exists(target_file):
+                try:
+                    with open(target_file, "r", encoding="utf-8") as f:
+                        actual_file_content = f.read()
+                except Exception as e:
+                    return f"Error reading {target_file} for backup: {e}"
+            else:
+                return f"Error: File {target_file} does not exist."
+
+            # Use provided original_code or fall back to file content
+            code_to_process = original_code if original_code is not None else actual_file_content
+
+            # Format the message for Morph's Fast Apply API
+            content = f"<instruction>{instructions}</instruction>\n<code>{code_to_process}</code>\n<update>{code_edit}</update>"
+
+            log_debug(f"Input to Morph: {content}")
+
+            client = self._get_client()
+
+            response = client.chat.completions.create(
+                model=self.model,
+                messages=[
+                    {
+                        "role": "user",
+                        "content": content,
+                    }
+                ],
+            )
+
+            if response.choices and response.choices[0].message.content:
+                final_code = response.choices[0].message.content
+
+                try:
+                    backup_file = f"{target_file}.backup"
+                    with open(backup_file, "w", encoding="utf-8") as f:
+                        f.write(actual_file_content)
+
+                    # Write the new code
+                    with open(target_file, "w", encoding="utf-8") as f:
+                        f.write(final_code)
+                    return f"Successfully applied edit to {target_file} using Morph Fast Apply! Original content backed up as {backup_file}"
+
+                except Exception as e:
+                    return f"Successfully applied edit but failed to write back to {target_file}: {e}"
+
+            else:
+                return f"Failed to apply edit to {target_file}: No response from Morph API"
+
+        except Exception as e:
+            log_error(f"Failed to apply edit using Morph Fast Apply: {e}")
+            return f"Failed to apply edit to {target_file}: {e}"
+
+    DEFAULT_INSTRUCTIONS = dedent("""\
+            You have access to Morph Fast Apply for ultra-fast code editing with 98% accuracy at 2500+ tokens/second.
+
+            ## How to use the edit_file tool:
+
+            **Critical Requirements:**
+            1. **Instructions Parameter**: Generate clear first-person instructions describing what you're doing
+            - Example: "I am adding type hints to all functions and methods"
+            - Example: "I am refactoring the error handling to use try-catch blocks"
+
+            2. **Code Edit Parameter**: Specify ONLY the lines you want to change
+            - Use `# ... existing code ...` (or `// ... existing code ...` for JS/Java) to represent unchanged sections
+            - NEVER write out unchanged code in the code_edit parameter
+            - Include sufficient context around changes to resolve ambiguity
+
+            3. **Single Edit Call**: Make ALL edits to a file in a single edit_file call. The apply model can handle many distinct edits at once.
+
+            **Example Format:**
+            ```
+            # ... existing code ...
+            def add(a: int, b: int) -> int:
+                \"\"\"Add two numbers together.\"\"\"
+                return a + b
+            # ... existing code ...
+            def multiply(x: int, y: int) -> int:
+                \"\"\"Multiply two numbers.\"\"\"
+                return x * y
+            # ... existing code ...
+            ```
+
+            **Important Guidelines:**
+            - Bias towards repeating as few lines as possible while conveying the change clearly
+            - Each edit should contain sufficient context of unchanged lines around the code you're editing
+            - DO NOT omit spans of pre-existing code without using the `# ... existing code ...` comment
+            - If deleting a section, provide context before and after to clearly indicate the deletion
+            - The tool automatically creates backup files before applying changes\
+        """)

agno/tools/models/nebius.py

@@ -0,0 +1,124 @@
+import base64
+from os import getenv
+from typing import Optional
+from uuid import uuid4
+
+from agno.agent import Agent
+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
+
+
+class NebiusTools(Toolkit):
+    """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.tokenfactory.nebius.com/v1",
+        image_model: str = "black-forest-labs/flux-schnell",
+        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 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 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)
+                  - "stability-ai/sdxl" (highest quality)
+            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.
+        """
+        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:
+            raise ValueError("NEBIUS_API_KEY not set. Please set the NEBIUS_API_KEY environment variable.")
+
+        self.base_url = base_url
+        self.image_model = image_model
+        self.image_quality = image_quality
+        self.image_size = image_size
+        self.image_style = image_style
+        self._nebius_client: Optional[Nebius] = None
+
+    def _get_client(self):
+        if self._nebius_client is None:
+            self._nebius_client = Nebius(api_key=self.api_key, base_url=self.base_url, id=self.image_model).get_client()  # type: ignore
+        return self._nebius_client
+
+    def generate_image(
+        self,
+        agent: Agent,
+        prompt: str,
+    ) -> ToolResult:
+        """Generate images based on a text prompt using Nebius Token Factory.
+
+        Args:
+            agent: The agent instance for adding images
+            prompt: The text prompt to generate images from.
+
+        Returns:
+            ToolResult: A ToolResult containing the generated image or error message.
+        """
+        try:
+            extra_params = {
+                "size": self.image_size,
+                "quality": self.image_quality,
+                "style": self.image_style,
+            }
+            extra_params = {k: v for k, v in extra_params.items() if v is not None}
+
+            client = self._get_client()
+
+            response = client.images.generate(
+                model=self.image_model,
+                prompt=prompt,
+                response_format="b64_json",
+                **extra_params,
+            )
+
+            data = None
+            if hasattr(response, "data") and response.data:
+                data = response.data[0]
+            if data is None:
+                log_warning("Nebius API did not return any data.")
+                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())
+
+                # Create ImageArtifact with raw bytes
+                image_artifact = Image(
+                    id=media_id, content=image_content_bytes, mime_type="image/png", original_prompt=prompt
+                )
+
+                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 ToolResult(content=f"Failed to generate image: {e}")

agno/tools/models_labs.py

@@ -1,124 +1,205 @@
 import json
 import time
 from os import getenv
-from typing import Optional
+from typing import Any, Dict, List, Optional, Union
 from uuid import uuid4
 
-from agno.agent import Agent
-from agno.media import ImageArtifact, VideoArtifact
+from agno.media import Audio, Image, Video
 from agno.models.response import FileType
 from agno.tools import Toolkit
-from agno.utils.log import logger
+from agno.tools.function import ToolResult
+from agno.utils.log import log_debug, log_info, logger
 
 try:
     import requests
+    from requests.exceptions import RequestException
 except ImportError:
     raise ImportError("`requests` not installed. Please install using `pip install requests`")
 
+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",
+}
+
 
 class ModelsLabTools(Toolkit):
     def __init__(
         self,
         api_key: Optional[str] = None,
-        url: str = "https://modelslab.com/api/v6/video/text2video",
-        fetch_url: str = "https://modelslab.com/api/v6/video/fetch",
-        # Whether to wait for the video to be ready
         wait_for_completion: bool = False,
-        # Time to add to the ETA to account for the time it takes to fetch the video
         add_to_eta: int = 15,
-        # Maximum time to wait for the video to be ready
         max_wait_time: int = 60,
         file_type: FileType = FileType.MP4,
+        **kwargs,
     ):
-        super().__init__(name="models_labs")
-
-        self.url = url
-        self.fetch_url = fetch_url
+        file_type_str = file_type.value.upper()
+        self.url = MODELS_LAB_URLS[file_type_str]
+        self.fetch_url = MODELS_LAB_FETCH_URLS[file_type_str]
         self.wait_for_completion = wait_for_completion
         self.add_to_eta = add_to_eta
         self.max_wait_time = max_wait_time
         self.file_type = file_type
         self.api_key = api_key or getenv("MODELS_LAB_API_KEY")
+
         if not self.api_key:
             logger.error("MODELS_LAB_API_KEY not set. Please set the MODELS_LAB_API_KEY environment variable.")
 
-        self.register(self.generate_media)
-
-    def generate_media(self, agent: Agent, prompt: str) -> str:
-        """Use this function to generate a video or image given a prompt.
-
-        Args:
-            prompt (str): A text description of the desired video.
-
-        Returns:
-            str: A message indicating if the video has been generated successfully or an error message.
-        """
+        tools: List[Any] = []
+        tools.append(self.generate_media)
+
+        super().__init__(name="models_labs", tools=tools, **kwargs)
+
+    def _create_payload(self, prompt: str) -> Dict[str, Any]:
+        """Create payload based on file type."""
+        base_payload: Dict[str, Any] = {
+            "key": self.api_key,
+            "prompt": prompt,
+            "webhook": None,
+            "track_id": None,
+        }
+
+        if self.file_type in [FileType.MP4, FileType.GIF]:
+            video_template = {
+                "height": 512,
+                "width": 512,
+                "num_frames": 25,
+                "negative_prompt": "low quality",
+                "model_id": "cogvideox",
+                "instant_response": False,
+                "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,
+                "temp": False,
+            }
+            base_payload |= audio_template  # Use |= instead of update()
+
+        return base_payload
+
+    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:
+            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 = Image(id=str(media_id), url=media_url)
+            artifacts["images"].append(image_artifact)
+        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
+
+    def _wait_for_media(self, media_id: str, eta: int) -> bool:
+        """Wait for media generation to complete."""
+        time_to_wait = min(eta + self.add_to_eta, self.max_wait_time)
+        log_info(f"Waiting for {time_to_wait} seconds for {self.file_type.value} to be ready")
+
+        for seconds_waited in range(time_to_wait):
+            try:
+                fetch_response = requests.post(
+                    f"{self.fetch_url}/{media_id}",
+                    json={"key": self.api_key},
+                    headers={"Content-Type": "application/json"},
+                )
+                fetch_result = fetch_response.json()
+
+                if fetch_result.get("status") == "success":
+                    return True
+
+                time.sleep(1)
+
+            except RequestException as e:
+                logger.warning(f"Error during fetch attempt {seconds_waited}: {e}")
+
+        return False
+
+    def generate_media(self, 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(
-                {
-                    "key": self.api_key,
-                    "prompt": prompt,
-                    "height": 512,
-                    "width": 512,
-                    "num_frames": 25,
-                    "webhook": None,
-                    "output_type": self.file_type.value,
-                    "track_id": None,
-                    "negative_prompt": "low quality",
-                    "model_id": "cogvideox",
-                    "instant_response": False,
-                }
-            )
-
+            payload = json.dumps(self._create_payload(prompt))
             headers = {"Content-Type": "application/json"}
-            logger.debug(f"Generating video for prompt: {prompt}")
-            response = requests.request("POST", self.url, data=payload, headers=headers)
+
+            log_debug(f"Generating {self.file_type.value} for prompt: {prompt}")
+            response = requests.post(self.url, data=payload, headers=headers)
             response.raise_for_status()
 
             result = response.json()
-            if "error" in result:
-                logger.error(f"Failed to generate video: {result['error']}")
-                return f"Error: {result['error']}"
-
-            eta = result["eta"]
-            url_links = result["future_links"]
-            logger.info(f"Media will be ready in {eta} seconds")
-            logger.info(f"Media URLs: {url_links}")
 
-            video_id = str(uuid4())
+            status = result.get("status")
+            if status == "error":
+                logger.error(f"Error in response: {result.get('message')}")
+                return ToolResult(content=f"Error: {result.get('message')}")
 
-            logger.debug(f"Result: {result}")
+            if "error" in result:
+                error_msg = f"Failed to generate {self.file_type.value}: {result['error']}"
+                logger.error(error_msg)
+                return ToolResult(content=f"Error: {result['error']}")
+
+            eta = result.get("eta")
+            media_id = str(uuid4())
+
+            # Collect all media artifacts
+            all_images = []
+            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:
-                if self.file_type == FileType.MP4:
-                    agent.add_video(VideoArtifact(id=str(video_id), url=media_url, eta=str(eta)))
-                elif self.file_type == FileType.GIF:
-                    agent.add_image(ImageArtifact(id=str(video_id), url=media_url))
-
-            if self.wait_for_completion and isinstance(eta, int):
-                video_ready = False
-                seconds_waited = 0
-                time_to_wait = min(eta + self.add_to_eta, self.max_wait_time)
-                logger.info(f"Waiting for {time_to_wait} seconds for video to be ready")
-                while not video_ready and seconds_waited < time_to_wait:
-                    time.sleep(1)
-                    seconds_waited += 1
-                    # Fetch the video from the ModelsLabs API
-                    fetch_payload = json.dumps({"key": self.api_key})
-                    fetch_headers = {"Content-Type": "application/json"}
-                    logger.debug(f"Fetching video from {self.fetch_url}/{video_id}")
-                    fetch_response = requests.request(
-                        "POST", f"{self.fetch_url}/{video_id}", data=fetch_payload, headers=fetch_headers
-                    )
-                    fetch_result = fetch_response.json()
-                    logger.debug(f"Fetch result: {fetch_result}")
-                    if fetch_result.get("status") == "success":
-                        video_ready = True
-                        break
-
-            return f"Video has been generated successfully and will be ready in {eta} seconds"
+                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")
+
+            # 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 ToolResult(content=f"Error: {error_msg}")
         except Exception as e:
-            logger.error(f"Failed to generate video: {e}")
-            return f"Error: {e}"
+            error_msg = f"Unexpected error while generating {self.file_type.value}: {e}"
+            logger.error(error_msg)
+            return ToolResult(content=f"Error: {error_msg}")

agno/tools/moviepy_video.py

@@ -1,7 +1,7 @@
-from typing import Dict, List, Optional
+from typing import Any, Dict, List, Optional
 
 from agno.tools import Toolkit
-from agno.utils.log import logger
+from agno.utils.log import log_debug, log_info, logger
 
 try:
     from moviepy import ColorClip, CompositeVideoClip, TextClip, VideoFileClip  # type: ignore
@@ -14,18 +14,21 @@ 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,
     ):
-        super().__init__(name="video_tools")
+        tools: List[Any] = []
+        if enable_process_video or all:
+            tools.append(self.extract_audio)
+        if enable_generate_captions or all:
+            tools.append(self.create_srt)
+        if enable_embed_captions or all:
+            tools.append(self.embed_captions)
 
-        if process_video:
-            self.register(self.extract_audio)
-        if generate_captions:
-            self.register(self.create_srt)
-        if embed_captions:
-            self.register(self.embed_captions)
+        super().__init__(name="video_tools", tools=tools, **kwargs)
 
     def split_text_into_lines(self, words: List[Dict]) -> List[Dict]:
         """Split transcribed words into lines based on duration and length constraints
@@ -227,9 +230,10 @@ class MoviePyVideoTools(Toolkit):
             str: Path to the extracted audio file
         """
         try:
+            log_debug(f"Extracting audio from {video_path}")
             video = VideoFileClip(video_path)
             video.audio.write_audiofile(output_path)
-            logger.info(f"Audio extracted to {output_path}")
+            log_info(f"Audio extracted to {output_path}")
             return output_path
         except Exception as e:
             logger.error(f"Failed to extract audio: {str(e)}")
@@ -244,6 +248,7 @@ class MoviePyVideoTools(Toolkit):
             str: Path to the created SRT file, or error message if failed
         """
         try:
+            log_debug(f"Creating SRT file at {output_path}")
             # Since we're getting SRT format from Whisper API now,
             # we can just write it directly to file
             with open(output_path, "w", encoding="utf-8") as f: