agno 2.2.13__py3-none-any.whl

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

@@ -0,0 +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.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`")
+
+# 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 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.")
+
+        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
+
+        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
+        """
+        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:
+            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
+                )
+            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:
+            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

@@ -0,0 +1,160 @@
+import json
+from os import getenv
+from typing import Any, List, Literal, Optional
+
+from agno.tools import Toolkit
+from agno.utils.log import log_debug, logger
+
+try:
+    from openbb import obb as openbb_app
+except ImportError:
+    raise ImportError("`openbb` not installed. Please install using `pip install 'openbb'`.")
+
+
+class OpenBBTools(Toolkit):
+    def __init__(
+        self,
+        obb: Optional[Any] = None,
+        openbb_pat: Optional[str] = None,
+        provider: Literal["benzinga", "fmp", "intrinio", "polygon", "tiingo", "tmx", "yfinance"] = "yfinance",
+        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,
+    ):
+        self.obb = obb or openbb_app
+        try:
+            if openbb_pat or getenv("OPENBB_PAT"):
+                self.obb.account.login(pat=openbb_pat or getenv("OPENBB_PAT"))  # type: ignore
+        except Exception as e:
+            logger.error(f"Error logging into OpenBB: {e}")
+
+        self.provider: Literal["benzinga", "fmp", "intrinio", "polygon", "tiingo", "tmx", "yfinance"] = provider
+
+        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.
+
+        Args:
+            symbol (str): The stock symbol or list of stock symbols.
+                Eg: "AAPL" or "AAPL,MSFT,GOOGL"
+
+        Returns:
+          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():
+                clean_results.append(
+                    {
+                        "symbol": row.get("symbol"),
+                        "last_price": row.get("last_price"),
+                        "currency": row.get("currency"),
+                        "name": row.get("name"),
+                        "high": row.get("high"),
+                        "low": row.get("low"),
+                        "open": row.get("open"),
+                        "close": row.get("close"),
+                        "prev_close": row.get("prev_close"),
+                        "volume": row.get("volume"),
+                        "ma_50d": row.get("ma_50d"),
+                        "ma_200d": row.get("ma_200d"),
+                    }
+                )
+            return json.dumps(clean_results, indent=2, default=str)
+        except Exception as e:
+            return f"Error fetching current price for {symbol}: {e}"
+
+    def search_company_symbol(self, company_name: str) -> str:
+        """Use this function to get a list of ticker symbols for a company.
+
+        Args:
+            company_name (str): The name of the company.
+
+        Returns:
+            str: A JSON string containing the ticker symbols.
+        """
+
+        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:
+            for row in result.to_dicts():
+                clean_results.append({"symbol": row.get("symbol"), "name": row.get("name")})
+
+        return json.dumps(clean_results, indent=2, default=str)
+
+    def get_price_targets(self, symbol: str) -> str:
+        """Use this function to get consensus price target and recommendations for a stock symbol or list of symbols.
+
+        Args:
+            symbol (str): The stock symbol or list of stock symbols.
+                Eg: "AAPL" or "AAPL,MSFT,GOOGL"
+
+        Returns:
+            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:
+            return f"Error fetching company news for {symbol}: {e}"
+
+    def get_company_news(self, symbol: str, num_stories: int = 10) -> str:
+        """Use this function to get company news for a stock symbol or list of symbols.
+
+        Args:
+            symbol (str): The stock symbol or list of stock symbols.
+                Eg: "AAPL" or "AAPL,MSFT,GOOGL"
+            num_stories (int): The number of news stories to return. Defaults to 10.
+
+        Returns:
+            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:
+                for row in result.to_dicts():
+                    row.pop("images")
+                    clean_results.append(row)
+            return json.dumps(clean_results[:num_stories], indent=2, default=str)
+        except Exception as e:
+            return f"Error fetching company news for {symbol}: {e}"
+
+    def get_company_profile(self, symbol: str) -> str:
+        """Use this function to get company profile and overview for a stock symbol or list of symbols.
+
+        Args:
+            symbol (str): The stock symbol or list of stock symbols.
+                Eg: "AAPL" or "AAPL,MSFT,GOOGL"
+
+        Returns:
+            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:
+            return f"Error fetching company profile for {symbol}: {e}"