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

agno/tools/openai.py

@@ -1,38 +1,202 @@
+from os import getenv
+from typing import Any, List, Literal, Optional, Union
+from uuid import uuid4
+
+from agno.agent import Agent
+from agno.media import Audio, Image
+from agno.team.team import Team
 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_error, log_warning
 
 try:
     from openai import OpenAI as OpenAIClient
 except (ModuleNotFoundError, ImportError):
     raise ImportError("`openai` not installed. Please install using `pip install openai`")
 
-
-client = OpenAIClient()
+# Define only types specifically needed by OpenAITools class
+OpenAIVoice = Literal["alloy", "echo", "fable", "onyx", "nova", "shimmer"]
+OpenAITTSModel = Literal["tts-1", "tts-1-hd"]
+OpenAITTSFormat = Literal["mp3", "opus", "aac", "flac", "wav", "pcm"]
 
 
 class OpenAITools(Toolkit):
-    """Tools for interacting with OpenAIChat API"""
+    """Tools for interacting with OpenAI API.
+
+    Args:
+        api_key (str, optional): OpenAI API key. Retrieved from OPENAI_API_KEY env variable if not provided.
+        enable_transcription (bool): Enable audio transcription functionality. Default is True.
+        enable_image_generation (bool): Enable image generation functionality. Default is True.
+        enable_speech_generation (bool): Enable speech generation functionality. Default is True.
+        all (bool): Enable all tools. Overrides individual flags when True. Default is False.
+        transcription_model (str): Model to use for transcription. Default is "whisper-1".
+        text_to_speech_voice (OpenAIVoice): Voice to use for TTS. Default is "alloy".
+        text_to_speech_model (OpenAITTSModel): Model to use for TTS. Default is "tts-1".
+        text_to_speech_format (OpenAITTSFormat): Audio format for TTS. Default is "mp3".
+        image_model (str, optional): Model to use for image generation. Default is "dall-e-3".
+        image_quality (str, optional): Quality setting for image generation.
+        image_size (str, optional): Size setting for image generation.
+        image_style (str, optional): Style setting for image generation.
+    """
+
+    def __init__(
+        self,
+        api_key: Optional[str] = None,
+        enable_transcription: bool = True,
+        enable_image_generation: bool = True,
+        enable_speech_generation: bool = True,
+        all: bool = False,
+        transcription_model: str = "whisper-1",
+        text_to_speech_voice: OpenAIVoice = "alloy",
+        text_to_speech_model: OpenAITTSModel = "tts-1",
+        text_to_speech_format: OpenAITTSFormat = "mp3",
+        image_model: Optional[str] = "dall-e-3",
+        image_quality: Optional[str] = None,
+        image_size: Optional[Literal["256x256", "512x512", "1024x1024", "1792x1024", "1024x1792"]] = None,
+        image_style: Optional[Literal["vivid", "natural"]] = None,
+        **kwargs,
+    ):
+        self.api_key = api_key or getenv("OPENAI_API_KEY")
+        if not self.api_key:
+            raise ValueError("OPENAI_API_KEY not set. Please set the OPENAI_API_KEY environment variable.")
 
-    def __init__(self):
-        super().__init__(name="openai_tools")
+        self.transcription_model = transcription_model
+        # Store TTS defaults
+        self.tts_voice = text_to_speech_voice
+        self.tts_model = text_to_speech_model
+        self.tts_format = text_to_speech_format
+        self.image_model = image_model
+        self.image_quality = image_quality
+        self.image_style = image_style
+        self.image_size = image_size
 
-        self.register(self.transcribe_audio)
+        tools: List[Any] = []
+        if all or enable_transcription:
+            tools.append(self.transcribe_audio)
+        if all or enable_image_generation:
+            tools.append(self.generate_image)
+        if all or enable_speech_generation:
+            tools.append(self.generate_speech)
+
+        super().__init__(name="openai_tools", tools=tools, **kwargs)
 
     def transcribe_audio(self, audio_path: str) -> str:
         """Transcribe audio file using OpenAI's Whisper API
         Args:
             audio_path: Path to the audio file
-        Returns:
-            str: Transcribed text
         """
-        logger.info(f"Transcribing audio from {audio_path}")
+        log_debug(f"Transcribing audio from {audio_path}")
+        try:
+            audio_file = open(audio_path, "rb")
+
+            transcript = OpenAIClient(api_key=self.api_key).audio.transcriptions.create(
+                model=self.transcription_model,
+                file=audio_file,
+                response_format="text",
+            )
+        except Exception as e:  # type: ignore[return]
+            log_error(f"Failed to transcribe audio: {str(e)}")
+            return f"Failed to transcribe audio: {str(e)}"
+
+        log_debug(f"Transcript: {transcript}")
+        return transcript  # type: ignore[return-value]
+
+    def generate_image(
+        self,
+        prompt: str,
+    ) -> ToolResult:
+        """Generate images based on a text prompt.
+        Args:
+            prompt (str): The text prompt to generate the image from.
+        """
         try:
-            with open(audio_path, "rb") as audio_file:
-                transcript = client.audio.transcriptions.create(
-                    model="whisper-1", file=audio_file, response_format="srt"
+            import base64
+
+            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}
+
+            # gpt-image-1 by default outputs a base64 encoded image but other models do not
+            # so we add a response_format parameter to have consistent output.
+            if self.image_model and self.image_model.startswith("gpt-image"):
+                response = OpenAIClient(api_key=self.api_key).images.generate(
+                    model=self.image_model,
+                    prompt=prompt,
+                    **extra_params,  # type: ignore
                 )
-                logger.info(f"Transcript: {transcript}")
-            return transcript
+            else:
+                response = OpenAIClient(api_key=self.api_key).images.generate(
+                    model=self.image_model,
+                    prompt=prompt,
+                    response_format="b64_json",
+                    **extra_params,  # type: ignore
+                )
+            data = None
+            if hasattr(response, "data") and response.data:
+                data = response.data[0]
+            if data is None:
+                log_warning("OpenAI 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
+                media_id = str(uuid4())
+
+                # Decode base64 to bytes for proper storage
+                image_bytes = base64.b64decode(image_base64)
+
+                # Create ImageArtifact and return in ToolResult
+                image_artifact = Image(
+                    id=media_id,
+                    content=image_bytes,  # ← Store as bytes, not encoded string
+                    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:
-            logger.error(f"Failed to transcribe audio: {str(e)}")
-            return f"Failed to transcribe audio: {str(e)}"
+            log_error(f"Failed to generate image using {self.image_model}: {e}")
+            return ToolResult(content=f"Failed to generate image: {e}")
+
+    def generate_speech(
+        self,
+        agent: Union[Agent, Team],
+        text_input: str,
+    ) -> ToolResult:  # Changed return type
+        """Generate speech from text using OpenAI's Text-to-Speech API.
+        Args:
+            text_input (str): The text to synthesize into speech.
+        """
+        try:
+            response = OpenAIClient(api_key=self.api_key).audio.speech.create(
+                model=self.tts_model,
+                voice=self.tts_voice,
+                input=text_input,
+                response_format=self.tts_format,
+            )
+
+            # Get raw audio data for artifact creation before potentially saving
+            audio_data: bytes = response.content
+
+            # Create AudioArtifact and return in ToolResult
+            media_id = str(uuid4())
+            audio_artifact = Audio(
+                id=media_id,
+                content=audio_data,
+                mime_type=f"audio/{self.tts_format}",
+            )
+
+            return ToolResult(
+                content=f"Speech generated successfully with ID: {media_id}",
+                audios=[audio_artifact],
+            )
+        except Exception as e:
+            return ToolResult(content=f"Failed to generate speech: {str(e)}")

agno/tools/openbb.py

@@ -1,9 +1,9 @@
 import json
 from os import getenv
-from typing import Any, Literal, Optional
+from typing import Any, List, Literal, Optional
 
 from agno.tools import Toolkit
-from agno.utils.log import logger
+from agno.utils.log import log_debug, logger
 
 try:
     from openbb import obb as openbb_app
@@ -17,14 +17,14 @@ class OpenBBTools(Toolkit):
         obb: Optional[Any] = None,
         openbb_pat: Optional[str] = None,
         provider: Literal["benzinga", "fmp", "intrinio", "polygon", "tiingo", "tmx", "yfinance"] = "yfinance",
-        stock_price: bool = True,
-        search_symbols: bool = False,
-        company_news: bool = False,
-        company_profile: bool = False,
-        price_targets: bool = False,
+        enable_get_stock_price: bool = True,
+        enable_search_company_symbol: bool = False,
+        enable_get_company_news: bool = False,
+        enable_get_company_profile: bool = False,
+        enable_get_price_targets: bool = False,
+        all: bool = False,
+        **kwargs,
     ):
-        super().__init__(name="yfinance_tools")
-
         self.obb = obb or openbb_app
         try:
             if openbb_pat or getenv("OPENBB_PAT"):
@@ -34,16 +34,19 @@ class OpenBBTools(Toolkit):
 
         self.provider: Literal["benzinga", "fmp", "intrinio", "polygon", "tiingo", "tmx", "yfinance"] = provider
 
-        if stock_price:
-            self.register(self.get_stock_price)
-        if search_symbols:
-            self.register(self.search_company_symbol)
-        if company_news:
-            self.register(self.get_company_news)
-        if company_profile:
-            self.register(self.get_company_profile)
-        if price_targets:
-            self.register(self.get_price_targets)
+        tools: List[Any] = []
+        if enable_get_stock_price or all:
+            tools.append(self.get_stock_price)
+        if enable_search_company_symbol or all:
+            tools.append(self.search_company_symbol)
+        if enable_get_company_news or all:
+            tools.append(self.get_company_news)
+        if enable_get_company_profile or all:
+            tools.append(self.get_company_profile)
+        if enable_get_price_targets or all:
+            tools.append(self.get_price_targets)
+
+        super().__init__(name="openbb_tools", tools=tools, **kwargs)
 
     def get_stock_price(self, symbol: str) -> str:
         """Use this function to get the current stock price for a stock symbol or list of symbols.
@@ -56,6 +59,7 @@ class OpenBBTools(Toolkit):
           str: The current stock prices or error message.
         """
         try:
+            log_debug(f"Fetching current price for {symbol}")
             result = self.obb.equity.price.quote(symbol=symbol, provider=self.provider).to_polars()  # type: ignore
             clean_results = []
             for row in result.to_dicts():
@@ -89,7 +93,7 @@ class OpenBBTools(Toolkit):
             str: A JSON string containing the ticker symbols.
         """
 
-        logger.debug(f"Search ticker for {company_name}")
+        log_debug(f"Search ticker for {company_name}")
         result = self.obb.equity.search(company_name).to_polars()  # type: ignore
         clean_results = []
         if len(result) > 0:
@@ -109,6 +113,7 @@ class OpenBBTools(Toolkit):
             str: JSON containing consensus price target and recommendations.
         """
         try:
+            log_debug(f"Fetching price targets for {symbol}")
             result = self.obb.equity.estimates.consensus(symbol=symbol, provider=self.provider).to_polars()  # type: ignore
             return json.dumps(result.to_dicts(), indent=2, default=str)
         except Exception as e:
@@ -126,6 +131,7 @@ class OpenBBTools(Toolkit):
             str: JSON containing company news and press releases.
         """
         try:
+            log_debug(f"Fetching news for {symbol}")
             result = self.obb.news.company(symbol=symbol, provider=self.provider, limit=num_stories).to_polars()  # type: ignore
             clean_results = []
             if len(result) > 0:
@@ -147,6 +153,7 @@ class OpenBBTools(Toolkit):
             str: JSON containing company profile and overview.
         """
         try:
+            log_debug(f"Fetching company profile for {symbol}")
             result = self.obb.equity.profile(symbol=symbol, provider=self.provider).to_polars()  # type: ignore
             return json.dumps(result.to_dicts(), indent=2, default=str)
         except Exception as e:

agno/tools/opencv.py

@@ -0,0 +1,321 @@
+import time
+from pathlib import Path
+from typing import Callable, List
+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:
+    import cv2
+except ImportError:
+    raise ImportError("`opencv-python` package not found. Please install it with `pip install opencv-python`")
+
+
+class OpenCVTools(Toolkit):
+    """Tools for capturing images and videos from the webcam using OpenCV"""
+
+    def __init__(
+        self,
+        show_preview=False,
+        enable_capture_image: bool = True,
+        enable_capture_video: bool = True,
+        all: bool = False,
+        **kwargs,
+    ):
+        self.show_preview = show_preview
+
+        tools: List[Callable] = []
+        if all or enable_capture_image:
+            tools.append(self.capture_image)
+        if all or enable_capture_video:
+            tools.append(self.capture_video)
+
+        super().__init__(
+            name="opencv_tools",
+            tools=tools,
+            **kwargs,
+        )
+
+    def capture_image(
+        self,
+        agent: Agent,
+        prompt: str = "Webcam capture",
+    ) -> ToolResult:
+        """Capture an image from the webcam.
+
+        Args:
+            prompt (str): Description of the image capture. Defaults to "Webcam capture".
+
+        Returns:
+            ToolResult: A ToolResult containing the captured image or error message.
+        """
+        try:
+            log_debug("Initializing webcam for image capture...")
+            cam = cv2.VideoCapture(0)
+
+            if not cam.isOpened():
+                cam = cv2.VideoCapture(0, cv2.CAP_AVFOUNDATION)  # macOS
+            if not cam.isOpened():
+                cam = cv2.VideoCapture(0, cv2.CAP_DSHOW)  # Windows
+            if not cam.isOpened():
+                cam = cv2.VideoCapture(0, cv2.CAP_V4L2)  # Linux
+
+            if not cam.isOpened():
+                error_msg = "Could not open webcam. Please ensure your terminal has camera permissions and the camera is not being used by another application."
+                log_error(error_msg)
+                return ToolResult(content=error_msg)
+
+            try:
+                cam.set(cv2.CAP_PROP_FRAME_WIDTH, 1280)
+                cam.set(cv2.CAP_PROP_FRAME_HEIGHT, 720)
+                cam.set(cv2.CAP_PROP_FPS, 30)
+
+                log_debug("Camera initialized successfully")
+                captured_frame = None
+
+                if self.show_preview:
+                    log_info("Live preview started. Press 'c' to capture image, 'q' to quit.")
+
+                    while True:
+                        ret, frame = cam.read()
+                        if not ret:
+                            error_msg = "Failed to read frame from webcam"
+                            log_error(error_msg)
+                            return ToolResult(content=error_msg)
+
+                        cv2.imshow('Camera Preview - Press "c" to capture, "q" to quit', frame)
+
+                        key = cv2.waitKey(1) & 0xFF
+                        if key == ord("c"):
+                            captured_frame = frame.copy()
+                            log_info("Image captured!")
+                            break
+                        elif key == ord("q"):
+                            log_info("Capture cancelled by user")
+                            return ToolResult(content="Image capture cancelled by user")
+                else:
+                    ret, captured_frame = cam.read()
+                    if not ret:
+                        error_msg = "Failed to capture image from webcam"
+                        log_error(error_msg)
+                        return ToolResult(content=error_msg)
+
+                if captured_frame is None:
+                    error_msg = "No frame captured"
+                    log_error(error_msg)
+                    return ToolResult(content=error_msg)
+
+                success, encoded_image = cv2.imencode(".png", captured_frame)
+
+                if not success:
+                    error_msg = "Failed to encode captured image"
+                    log_error(error_msg)
+                    return ToolResult(content=error_msg)
+
+                image_bytes = encoded_image.tobytes()
+                media_id = str(uuid4())
+
+                # Create ImageArtifact with raw bytes (not base64 encoded)
+                image_artifact = Image(
+                    id=media_id,
+                    content=image_bytes,  # Store as raw bytes
+                    original_prompt=prompt,
+                    mime_type="image/png",
+                )
+
+                log_debug(f"Successfully captured and attached image {media_id}")
+                return ToolResult(
+                    content="Image captured successfully",
+                    images=[image_artifact],
+                )
+
+            finally:
+                # Release the camera and close windows
+                cam.release()
+                cv2.destroyAllWindows()
+                log_debug("Camera resources released")
+
+        except Exception as e:
+            error_msg = f"Error capturing image: {str(e)}"
+            log_error(error_msg)
+            return ToolResult(content=error_msg)
+
+    def capture_video(
+        self,
+        agent: Agent,
+        duration: int = 10,
+        prompt: str = "Webcam video capture",
+    ) -> ToolResult:
+        """Capture a video from the webcam.
+
+        Args:
+            duration (int): Duration in seconds to record video. Defaults to 10 seconds.
+            prompt (str): Description of the video capture. Defaults to "Webcam video capture".
+
+        Returns:
+            ToolResult: A ToolResult containing the captured video or error message.
+        """
+        try:
+            log_debug("Initializing webcam for video capture...")
+            cap = cv2.VideoCapture(0)
+
+            # Try different backends for better compatibility
+            if not cap.isOpened():
+                cap = cv2.VideoCapture(0, cv2.CAP_AVFOUNDATION)  # macOS
+            if not cap.isOpened():
+                cap = cv2.VideoCapture(0, cv2.CAP_DSHOW)  # Windows
+            if not cap.isOpened():
+                cap = cv2.VideoCapture(0, cv2.CAP_V4L2)  # Linux
+
+            if not cap.isOpened():
+                error_msg = "Could not open webcam. Please ensure your terminal has camera permissions and the camera is not being used by another application."
+                log_error(error_msg)
+                return ToolResult(content=error_msg)
+
+            try:
+                frame_width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+                frame_height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+                actual_fps = cap.get(cv2.CAP_PROP_FPS)
+
+                # Use actual FPS or default to 30 if detection fails
+                if actual_fps <= 0 or actual_fps > 60:
+                    actual_fps = 30.0
+
+                log_debug(f"Video properties: {frame_width}x{frame_height} at {actual_fps} FPS")
+
+                # Try different codecs in order of preference for compatibility
+                codecs_to_try = [
+                    ("avc1", "H.264"),  # Most compatible
+                    ("mp4v", "MPEG-4"),  # Fallback
+                    ("XVID", "Xvid"),  # Another fallback
+                ]
+
+                import os
+                import tempfile
+
+                with tempfile.NamedTemporaryFile(suffix=".mp4", delete=False) as temp_file:
+                    temp_filepath = temp_file.name
+
+                out = None
+                successful_codec = None
+
+                for codec_fourcc, codec_name in codecs_to_try:
+                    try:
+                        fourcc = getattr(cv2, "VideoWriter_fourcc")(*codec_fourcc)
+                        out = cv2.VideoWriter(temp_filepath, fourcc, actual_fps, (frame_width, frame_height))
+
+                        if out.isOpened():
+                            successful_codec = codec_name
+                            log_debug(f"Successfully initialized video writer with {codec_name} codec")
+                            break
+                        else:
+                            out.release()
+                            out = None
+                    except Exception as e:
+                        log_debug(f"Failed to initialize {codec_name} codec: {e}")
+                        if out:
+                            out.release()
+                            out = None
+
+                if not out or not out.isOpened():
+                    error_msg = "Failed to initialize video writer with any codec"
+                    log_error(error_msg)
+                    return ToolResult(content=error_msg)
+
+                start_time = time.time()
+                frame_count = 0
+
+                if self.show_preview:
+                    log_info(f"Recording {duration}s video with live preview using {successful_codec} codec...")
+                else:
+                    log_info(f"Recording {duration}s video using {successful_codec} codec...")
+
+                while True:
+                    ret, frame = cap.read()
+
+                    if not ret:
+                        error_msg = "Failed to capture video frame"
+                        log_error(error_msg)
+                        return ToolResult(content=error_msg)
+
+                    # Write the frame to the output file
+                    out.write(frame)
+                    frame_count += 1
+
+                    # Show live preview if enabled
+                    if self.show_preview:
+                        # Add recording indicator
+                        elapsed = time.time() - start_time
+                        remaining = max(0, duration - elapsed)
+
+                        # Draw recording info on frame
+                        display_frame = frame.copy()
+                        cv2.putText(
+                            display_frame,
+                            f"REC {remaining:.1f}s",
+                            (10, 30),
+                            cv2.FONT_HERSHEY_SIMPLEX,
+                            1,
+                            (0, 0, 255),
+                            2,
+                        )
+                        cv2.circle(display_frame, (30, 60), 10, (0, 0, 255), -1)  # Red dot
+
+                        cv2.imshow(f"Recording Video - {remaining:.1f}s remaining", display_frame)
+                        cv2.waitKey(1)
+
+                    # Check if recording duration is reached
+                    if time.time() - start_time >= duration:
+                        break
+
+                # Release video writer
+                out.release()
+
+                # Verify the file was created and has content
+                temp_path = Path(temp_filepath)
+                if not temp_path.exists() or temp_path.stat().st_size == 0:
+                    error_msg = "Video file was not created or is empty"
+                    log_error(error_msg)
+                    return ToolResult(content=error_msg)
+
+                # Read the video file and encode to base64
+                with open(temp_filepath, "rb") as video_file:
+                    video_bytes = video_file.read()
+
+                # Clean up temporary file
+                os.unlink(temp_filepath)
+
+                media_id = str(uuid4())
+
+                # Create VideoArtifact with base64 encoded content
+                video_artifact = Video(
+                    id=media_id,
+                    content=video_bytes,
+                    original_prompt=prompt,
+                    mime_type="video/mp4",
+                )
+
+                actual_duration = time.time() - start_time
+                log_debug(
+                    f"Successfully captured and attached video {media_id} ({actual_duration:.1f}s, {frame_count} frames)"
+                )
+
+                return ToolResult(
+                    content=f"Video captured successfully and attached as artifact {media_id} ({actual_duration:.1f}s, {frame_count} frames, {successful_codec} codec)",
+                    videos=[video_artifact],
+                )
+
+            finally:
+                if "cap" in locals():
+                    cap.release()
+                cv2.destroyAllWindows()
+                log_debug("Video capture resources released")
+
+        except Exception as e:
+            error_msg = f"Error capturing video: {str(e)}"
+            log_error(error_msg)
+            return ToolResult(content=error_msg)