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

agno/tools/models/azure_openai.py

@@ -0,0 +1,190 @@
+from os import getenv
+from typing import Any, Dict, Literal, Optional
+from uuid import uuid4
+
+from requests import post
+
+from agno.agent import Agent
+from agno.media import Image
+from agno.tools import Toolkit
+from agno.tools.function import ToolResult
+from agno.utils.log import log_debug, logger
+
+
+class AzureOpenAITools(Toolkit):
+    """Toolkit for Azure OpenAI services.
+
+    Currently supports:
+    - DALL-E image generation
+    """
+
+    # Define valid parameter options as class constants
+    VALID_MODELS = ["dall-e-3", "dall-e-2"]
+    VALID_SIZES = ["256x256", "512x512", "1024x1024", "1792x1024", "1024x1792"]
+    VALID_QUALITIES = ["standard", "hd"]
+    VALID_STYLES = ["vivid", "natural"]
+
+    def __init__(
+        self,
+        api_key: Optional[str] = None,
+        azure_endpoint: Optional[str] = None,
+        api_version: Optional[str] = None,
+        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,
+    ):
+        # 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")
+        self.api_version = api_version or getenv("AZURE_OPENAI_API_VERSION") or "2023-12-01-preview"
+
+        # Log warnings for missing credentials
+        if not self.api_key:
+            logger.error("AZURE_OPENAI_API_KEY not set")
+        if not self.azure_endpoint:
+            logger.error("AZURE_OPENAI_ENDPOINT not set")
+
+        # Initialize image generation parameters
+        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}"
+            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
+        if self.image_quality not in self.VALID_QUALITIES:
+            self.image_quality = "standard"
+            log_debug(f"Enforcing valid quality: '{self.image_quality}' -> 'standard'")
+
+    def _enforce_valid_image_parameters(self, params: Dict[str, Any]) -> Dict[str, Any]:
+        """Enforce valid parameters by replacing invalid ones with defaults."""
+        enforced = params.copy()
+
+        # Validate size
+        if params.get("size") not in self.VALID_SIZES:
+            enforced["size"] = "1024x1024"
+            log_debug(f"Enforcing valid size: '{params.get('size')}' -> '1024x1024'")
+
+        # Validate style
+        if params.get("style") not in self.VALID_STYLES:
+            enforced["style"] = "vivid"
+            log_debug(f"Enforcing valid style: '{params.get('style')}' -> 'vivid'")
+
+        # Validate number of images
+        if not isinstance(params.get("n"), int) or params.get("n", 0) <= 0:
+            enforced["n"] = 1
+            log_debug(f"Enforcing valid n: '{params.get('n')}' -> 1")
+
+        # Special case: dall-e-3 only supports n=1
+        if enforced.get("model") == "dall-e-3" and enforced.get("n", 1) > 1:
+            enforced["n"] = 1
+            log_debug("Enforcing n=1 for dall-e-3 model")
+
+        return enforced
+
+    def generate_image(
+        self,
+        agent: Agent,
+        prompt: str,
+        n: int = 1,
+        size: Optional[Literal["256x256", "512x512", "1024x1024", "1792x1024", "1024x1792"]] = "1024x1024",
+        style: Literal["vivid", "natural"] = "vivid",
+    ) -> ToolResult:
+        """Generate an image using Azure OpenAI image generation.
+
+        Args:
+            agent: The agent instance for adding images
+            prompt: Text description of the desired image
+            n: Number of images to generate (default: 1).
+                Note: dall-e-3 only supports n=1, while dall-e-2 supports multiple images.
+            size: Image size.
+                Valid options: "256x256", "512x512", "1024x1024", "1792x1024", "1024x1792" (default: "1024x1024")
+                Note: Not all sizes are available for all models.
+            style: Image style.
+                Valid options: "vivid" or "natural" (default: "vivid")
+                Note: "vivid" produces more dramatic images, while "natural" produces more realistic ones.
+
+        Returns:
+            ToolResult: A ToolResult containing the generated images or error message.
+
+        Note:
+            Invalid parameters will be automatically corrected to valid values. For example:
+            - Invalid sizes will be changed to "1024x1024"
+            - Invalid quality values will be changed to "standard"
+            - Invalid style values will be changed to "vivid"
+            - For dall-e-3, n will always be set to 1
+        """
+        # Check if image generation is properly initialized
+        if not hasattr(self, "image_base_url"):
+            return ToolResult(
+                content="Image generation tool not properly initialized. Please check your configuration."
+            )
+
+        # Enforce valid parameters
+        params = self._enforce_valid_image_parameters(
+            {
+                "n": n,
+                "size": size,
+                "quality": self.image_quality,
+                "style": style,
+            }
+        )
+
+        # Add prompt and model to params - this wasn't included in enforcement because it doesn't need validation
+        params["prompt"] = prompt
+        params["model"] = self.image_model
+
+        try:
+            # Make API request using stored base URL
+            headers = {"api-key": self.api_key, "Content-Type": "application/json"}
+            response = post(self.image_base_url, headers=headers, json=params)
+
+            if response.status_code != 200:
+                return ToolResult(content=f"Error {response.status_code}: {response.text}")
+
+            # Process results
+            data = response.json()
+            log_debug("Image generated successfully")
+
+            # 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")
+
+                # 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"
+
+            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 ToolResult(content=f"Error: {e}")

agno/tools/models/gemini.py

@@ -0,0 +1,203 @@
+import base64
+import time
+from os import getenv
+from typing import Any, Optional
+from uuid import uuid4
+
+from agno.agent import Agent
+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:
+    from google.genai import Client
+    from google.genai.types import GenerateImagesResponse, GenerateVideosOperation
+except (ModuleNotFoundError, ImportError):
+    raise ImportError("`google-genai` not installed. Please install using `pip install google-genai`")
+
+
+class GeminiTools(Toolkit):
+    """Tools for interacting with Google Gemini API"""
+
+    def __init__(
+        self,
+        api_key: Optional[str] = None,
+        vertexai: bool = False,
+        project_id: Optional[str] = None,
+        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,
+    ):
+        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"
+        self.project_id = project_id
+        self.location = location
+
+        # Load API key from argument or environment
+        self.api_key = api_key or getenv("GOOGLE_API_KEY")
+        if not self.vertexai and not self.api_key:
+            log_error("GOOGLE_API_KEY not set. Please set the GOOGLE_API_KEY environment variable.")
+            raise ValueError("GOOGLE_API_KEY not set. Please provide api_key or set the environment variable.")
+
+        # Prepare client parameters
+        client_params: dict[str, Any] = {}
+        if self.vertexai:
+            log_info("Using Vertex AI API")
+            client_params["vertexai"] = True
+            client_params["project"] = self.project_id or getenv("GOOGLE_CLOUD_PROJECT")
+            client_params["location"] = self.location or getenv("GOOGLE_CLOUD_LOCATION")
+        else:
+            log_info("Using Gemini API")
+            client_params["api_key"] = self.api_key
+
+        try:
+            self.client = Client(**client_params)
+            log_debug("Google GenAI Client created successfully.")
+        except Exception as e:
+            log_error(f"Failed to create Google GenAI Client: {e}", exc_info=True)
+            raise ValueError(f"Failed to create Google GenAI Client. Error: {e}")
+
+        self.image_model = image_generation_model
+        self.video_model = video_generation_model
+
+    def generate_image(
+        self,
+        agent: Agent,
+        prompt: str,
+    ) -> ToolResult:
+        """Generate images based on a text prompt using Google Imagen.
+
+        Args:
+            prompt (str): The text prompt to generate the image from.
+        Returns:
+            ToolResult: A ToolResult containing the generated images or error message.
+        """
+
+        try:
+            response: GenerateImagesResponse = self.client.models.generate_images(
+                model=self.image_model,
+                prompt=prompt,
+            )
+
+            log_debug("DEBUG: Raw Gemini API response")
+
+            # Extract image bytes
+            if response.generated_images is None or not response.generated_images:
+                log_info("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
+                actual_mime_type = "image/png"
+                media_id = str(uuid4())
+
+                # 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}")
+
+            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 ToolResult(content=f"Failed to generate image: Client or method not available ({e})")
+
+    def generate_video(
+        self,
+        agent: Agent,
+        prompt: str,
+    ) -> ToolResult:
+        """Generate a video based on a text prompt.
+        Args:
+            prompt (str): The text prompt to generate the video from.
+        Returns:
+            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 ToolResult(
+                content="Video generation requires Vertex AI mode. "
+                "Please set `vertexai=True` or environment variable `GOOGLE_GENAI_USE_VERTEXAI=true`."
+            )
+
+        from google.genai.types import GenerateVideosConfig
+
+        try:
+            operation: GenerateVideosOperation = self.client.models.generate_videos(
+                model=self.video_model,
+                prompt=prompt,
+                config=GenerateVideosConfig(
+                    enhance_prompt=True,
+                ),
+            )
+
+            while not operation.done:
+                time.sleep(5)
+                operation = self.client.operations.get(operation=operation)
+
+            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 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())
+
+                # 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}")
+
+            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 ToolResult(content=f"Failed to generate video: {e}")

agno/tools/models/groq.py

@@ -0,0 +1,158 @@
+from os import getenv
+from pathlib import Path
+from typing import Any, List, Optional
+from uuid import uuid4
+
+from agno.agent import Agent
+from agno.media import Audio
+from agno.tools import Toolkit
+from agno.tools.function import ToolResult
+from agno.utils.log import log_debug, log_error
+
+try:
+    from groq import Groq as GroqClient
+except (ModuleNotFoundError, ImportError):
+    raise ImportError("`groq` not installed. Please install using `pip install groq`")
+
+
+class GroqTools(Toolkit):
+    """Tools for interacting with Groq API"""
+
+    def __init__(
+        self,
+        api_key: Optional[str] = None,
+        transcription_model: str = "whisper-large-v3",
+        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,
+    ):
+        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:
+            raise ValueError("GROQ_API_KEY not set. Please set the GROQ_API_KEY environment variable.")
+
+        self.client = GroqClient(api_key=self.api_key)
+        self.transcription_model = transcription_model
+        self.translation_model = translation_model
+        self.tts_model = tts_model
+        self.tts_voice = tts_voice
+        self.tts_format = "wav"
+
+    def transcribe_audio(self, audio_source: str) -> str:
+        """Transcribe audio file or URL using Groq's Whisper API.
+        Args:
+            audio_source: Path to the local audio file or a publicly accessible URL to the audio.
+        Returns:
+            str: Transcribed text
+        """
+        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 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,
+                    model=self.transcription_model,
+                    response_format="text",
+                )
+            else:
+                log_debug(f"Transcribing local file: {audio_source}")
+                with open(audio_source, "rb") as audio_file:
+                    transcription_text = self.client.audio.transcriptions.create(
+                        file=(Path(audio_source).name, audio_file.read()),
+                        model=self.transcription_model,
+                        response_format="text",
+                    )
+            log_debug(f"Transcript Generated: {transcription_text}")
+            return str(transcription_text)
+
+        except Exception as e:
+            log_error(f"Failed to transcribe audio source '{audio_source}' with Groq: {str(e)}")
+            return f"Failed to transcribe audio source '{audio_source}' with Groq: {str(e)}"
+
+    def translate_audio(self, audio_source: str) -> str:
+        """Translate audio file or URL to English using Groq's Whisper API.
+        Args:
+            audio_source: Path to the local audio file or a publicly accessible URL to the audio.
+        Returns:
+            str: Translated English text
+        """
+        log_debug(f"Translating audio from {audio_source} to English using Groq model {self.translation_model}")
+        try:
+            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,
+                    model=self.translation_model,
+                    response_format="text",
+                )
+            else:
+                log_debug(f"Translating local file: {audio_source}")
+                with open(audio_source, "rb") as audio_file:
+                    translation = self.client.audio.translations.create(
+                        file=(Path(audio_source).name, audio_file.read()),
+                        model=self.translation_model,
+                        response_format="text",
+                    )
+            log_debug(f"Groq Translation: {translation}")
+            return str(translation)
+
+        except Exception as e:
+            log_error(f"Failed to translate audio source '{audio_source}' with Groq: {str(e)}")
+            return f"Failed to translate audio source '{audio_source}' with Groq: {str(e)}"
+
+    def generate_speech(
+        self,
+        agent: Agent,
+        text_input: str,
+    ) -> ToolResult:
+        """Generate speech from text using Groq's Text-to-Speech API.
+
+        Args:
+            text_input: The text to synthesize into speech.
+        Returns:
+            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}"
+        )
+
+        try:
+            response = self.client.audio.speech.create(
+                model=self.tts_model,
+                voice=self.tts_voice,
+                input=text_input,
+                response_format="wav",
+            )
+
+            log_debug(f"Groq TTS Response: {response}")
+
+            audio_data: bytes = response.read()
+
+            media_id = str(uuid4())
+            audio_artifact = Audio(
+                id=media_id,
+                content=audio_data,
+                mime_type="audio/wav",
+            )
+
+            log_debug(f"Successfully generated speech artifact with ID: {media_id}")
+            return 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 ToolResult(content=f"Failed to generate speech with Groq: {str(e)}")