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

agno/tools/calculator.py

@@ -1,42 +1,29 @@
 import json
 import math
+from typing import Callable, List
 
 from agno.tools import Toolkit
-from agno.utils.log import logger
+from agno.utils.log import log_debug, logger
 
 
 class CalculatorTools(Toolkit):
     def __init__(
         self,
-        add: bool = True,
-        subtract: bool = True,
-        multiply: bool = True,
-        divide: bool = True,
-        exponentiate: bool = False,
-        factorial: bool = False,
-        is_prime: bool = False,
-        square_root: bool = False,
-        enable_all: bool = False,
+        **kwargs,
     ):
-        super().__init__(name="calculator")
-
-        # Register functions in the toolkit
-        if add or enable_all:
-            self.register(self.add)
-        if subtract or enable_all:
-            self.register(self.subtract)
-        if multiply or enable_all:
-            self.register(self.multiply)
-        if divide or enable_all:
-            self.register(self.divide)
-        if exponentiate or enable_all:
-            self.register(self.exponentiate)
-        if factorial or enable_all:
-            self.register(self.factorial)
-        if is_prime or enable_all:
-            self.register(self.is_prime)
-        if square_root or enable_all:
-            self.register(self.square_root)
+        tools: List[Callable] = [
+            self.add,
+            self.subtract,
+            self.multiply,
+            self.divide,
+            self.exponentiate,
+            self.factorial,
+            self.is_prime,
+            self.square_root,
+        ]
+
+        # Initialize the toolkit with auto-registration enabled
+        super().__init__(name="calculator", tools=tools, **kwargs)
 
     def add(self, a: float, b: float) -> str:
         """Add two numbers and return the result.
@@ -49,7 +36,7 @@ class CalculatorTools(Toolkit):
             str: JSON string of the result.
         """
         result = a + b
-        logger.info(f"Adding {a} and {b} to get {result}")
+        log_debug(f"Adding {a} and {b} to get {result}")
         return json.dumps({"operation": "addition", "result": result})
 
     def subtract(self, a: float, b: float) -> str:
@@ -63,7 +50,7 @@ class CalculatorTools(Toolkit):
             str: JSON string of the result.
         """
         result = a - b
-        logger.info(f"Subtracting {b} from {a} to get {result}")
+        log_debug(f"Subtracting {b} from {a} to get {result}")
         return json.dumps({"operation": "subtraction", "result": result})
 
     def multiply(self, a: float, b: float) -> str:
@@ -77,7 +64,7 @@ class CalculatorTools(Toolkit):
             str: JSON string of the result.
         """
         result = a * b
-        logger.info(f"Multiplying {a} and {b} to get {result}")
+        log_debug(f"Multiplying {a} and {b} to get {result}")
         return json.dumps({"operation": "multiplication", "result": result})
 
     def divide(self, a: float, b: float) -> str:
@@ -96,8 +83,8 @@ class CalculatorTools(Toolkit):
         try:
             result = a / b
         except Exception as e:
-            return json.dumps({"operation": "division", "error": e, "result": "Error"})
-        logger.info(f"Dividing {a} by {b} to get {result}")
+            return json.dumps({"operation": "division", "error": str(e), "result": "Error"})
+        log_debug(f"Dividing {a} by {b} to get {result}")
         return json.dumps({"operation": "division", "result": result})
 
     def exponentiate(self, a: float, b: float) -> str:
@@ -111,7 +98,7 @@ class CalculatorTools(Toolkit):
             str: JSON string of the result.
         """
         result = math.pow(a, b)
-        logger.info(f"Raising {a} to the power of {b} to get {result}")
+        log_debug(f"Raising {a} to the power of {b} to get {result}")
         return json.dumps({"operation": "exponentiation", "result": result})
 
     def factorial(self, n: int) -> str:
@@ -127,7 +114,7 @@ class CalculatorTools(Toolkit):
             logger.error("Attempt to calculate factorial of a negative number")
             return json.dumps({"operation": "factorial", "error": "Factorial of a negative number is undefined"})
         result = math.factorial(n)
-        logger.info(f"Calculating factorial of {n} to get {result}")
+        log_debug(f"Calculating factorial of {n} to get {result}")
         return json.dumps({"operation": "factorial", "result": result})
 
     def is_prime(self, n: int) -> str:
@@ -160,5 +147,5 @@ class CalculatorTools(Toolkit):
             return json.dumps({"operation": "square_root", "error": "Square root of a negative number is undefined"})
 
         result = math.sqrt(n)
-        logger.info(f"Calculating square root of {n} to get {result}")
+        log_debug(f"Calculating square root of {n} to get {result}")
         return json.dumps({"operation": "square_root", "result": result})

agno/tools/cartesia.py

@@ -0,0 +1,187 @@
+import json
+from os import getenv
+from typing import Any, Dict, List, Optional, Union
+from uuid import uuid4
+
+from agno.agent import Agent
+from agno.media import Audio
+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_info
+
+try:
+    import cartesia  # type: ignore
+except ImportError:
+    raise ImportError("`cartesia` not installed. Please install using `pip install cartesia`")
+
+
+class CartesiaTools(Toolkit):
+    def __init__(
+        self,
+        api_key: Optional[str] = None,
+        model_id: str = "sonic-2",
+        default_voice_id: str = "78ab82d5-25be-4f7d-82b3-7ad64e5b85b2",
+        enable_text_to_speech: bool = True,
+        enable_list_voices: bool = True,
+        enable_localize_voice: bool = False,
+        all: bool = False,
+        **kwargs,
+    ):
+        self.api_key = api_key or getenv("CARTESIA_API_KEY")
+
+        if not self.api_key:
+            raise ValueError("CARTESIA_API_KEY not set. Please set the CARTESIA_API_KEY environment variable.")
+
+        self.client = cartesia.Cartesia(api_key=self.api_key)
+        self.model_id = model_id
+        self.default_voice_id = default_voice_id
+
+        tools: List[Any] = []
+        if all or enable_localize_voice:
+            tools.append(self.localize_voice)
+        if all or enable_text_to_speech:
+            tools.append(self.text_to_speech)
+        if all or enable_list_voices:
+            tools.append(self.list_voices)
+
+        super().__init__(name="cartesia_tools", tools=tools, **kwargs)
+
+    def list_voices(self) -> str:
+        """List available voices from Cartesia (first page).
+
+        Returns:
+            str: JSON string containing a list of voices, each with id, name, description, and language.
+        """
+        try:
+            voices = self.client.voices.list()
+
+            voice_objects = voices.items if voices else None
+
+            filtered_result = []
+            if voice_objects:
+                for voice in voice_objects:
+                    try:
+                        # Extract desired attributes from the Voice object
+                        voice_data = {
+                            "id": voice.id if hasattr(voice, "id") else None,
+                            "name": voice.name if hasattr(voice, "name") else None,
+                            "description": voice.description if hasattr(voice, "description") else None,
+                            "language": voice.language if hasattr(voice, "language") else None,
+                        }
+
+                        if voice_data["id"]:  # Only add if we could get an ID
+                            filtered_result.append(voice_data)
+                        else:
+                            log_info(f"Could not extract 'id' from voice object: {voice}")
+                    except AttributeError as ae:
+                        log_error(f"AttributeError accessing voice data: {ae}. Voice data: {voice}")
+                        continue
+                    except Exception as inner_e:
+                        log_error(f"Unexpected error processing voice: {inner_e}. Voice data: {voice}")
+                        continue
+
+            return json.dumps(filtered_result, indent=4)
+        except Exception as e:
+            log_error(f"Error listing voices from Cartesia: {e}", exc_info=True)
+            return json.dumps({"error": str(e), "detail": "Error occurred in list_voices function."})
+
+    def localize_voice(
+        self,
+        name: str,
+        description: str,
+        language: str,
+        original_speaker_gender: str,
+        voice_id: Optional[str] = None,
+    ) -> str:
+        """Create a new voice localized to a different language.
+
+        Args:
+            name (str): The desired name for the new localized voice.
+            description (str): The description for the new localized voice.
+            language (str): The target language code (e.g., 'fr', 'es').
+            original_speaker_gender (str): The gender of the original speaker ("male" or "female").
+            voice_id (optional): The ID of an existing voice to use as the base. If None, uses the default voice ID configured in the tool. Defaults to None.
+
+        Returns:
+            str: JSON string containing the information of the newly created localized voice, including its 'id'.
+        """
+        localize_voice_id = voice_id or self.default_voice_id
+        log_debug(f"Using voice_id '{localize_voice_id}' for localization.")
+
+        try:
+            result = self.client.voices.localize(
+                voice_id=localize_voice_id,
+                name=name,
+                description=description,
+                language=language,
+                original_speaker_gender=original_speaker_gender,
+            )
+
+            if isinstance(result, dict):
+                return json.dumps(result, indent=4)
+            else:
+                return result.model_dump_json(indent=4)
+
+        except Exception as e:
+            log_error(f"Error localizing voice with Cartesia: {e}", exc_info=True)
+            return json.dumps({"error": str(e), "type": type(e).__name__})
+
+    def text_to_speech(
+        self,
+        agent: Union[Agent, Team],
+        transcript: str,
+        voice_id: Optional[str] = None,
+    ) -> ToolResult:
+        """
+        Convert text to speech.
+        Args:
+            transcript: The text to convert to speech
+            voice_id (optional): The ID of the voice to use for the text-to-speech. If None, uses the default voice ID configured in the tool. Defaults to None.
+
+        Returns:
+            ToolResult: A ToolResult containing the generated audio or error message.
+        """
+
+        try:
+            effective_voice_id = voice_id or self.default_voice_id
+
+            log_info(f"Using voice_id: {effective_voice_id} for text_to_speech.")
+            log_info(f"Using model_id: {self.model_id} for text_to_speech.")
+
+            output_format_sample_rate = 44100
+            requested_bit_rate = 128000
+            mime_type = "audio/mpeg"
+
+            output_format = {
+                "container": "mp3",
+                "sample_rate": output_format_sample_rate,
+                "bit_rate": requested_bit_rate,
+                "encoding": "mp3",
+            }
+
+            params: Dict[str, Any] = {
+                "model_id": self.model_id,
+                "transcript": transcript,
+                "voice": {"mode": "id", "id": effective_voice_id},
+                "output_format": output_format,
+            }
+
+            audio_iterator = self.client.tts.bytes(**params)
+            audio_data = b"".join(chunk for chunk in audio_iterator)
+
+            # Create AudioArtifact
+            audio_artifact = Audio(
+                id=str(uuid4()),
+                content=audio_data,
+                mime_type=mime_type,  # Hardcoded to audio/mpeg
+            )
+
+            return ToolResult(
+                content="Audio generated and attached successfully.",
+                audios=[audio_artifact],
+            )
+
+        except Exception as e:
+            log_error(f"Error generating speech with Cartesia: {e}", exc_info=True)
+            return ToolResult(content=f"Error generating speech: {e}")

agno/tools/{clickup_tool.py → clickup.py}

@@ -1,10 +1,10 @@
 import json
-import os
 import re
+from os import getenv
 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, logger
 
 try:
     import requests
@@ -17,18 +17,10 @@ class ClickUpTools(Toolkit):
         self,
         api_key: Optional[str] = None,
         master_space_id: Optional[str] = None,
-        list_tasks: bool = True,
-        create_task: bool = True,
-        get_task: bool = True,
-        update_task: bool = True,
-        delete_task: bool = True,
-        list_spaces: bool = True,
-        list_lists: bool = True,
+        **kwargs,
     ):
-        super().__init__(name="clickup")
-
-        self.api_key = api_key or os.getenv("CLICKUP_API_KEY")
-        self.master_space_id = master_space_id or os.getenv("MASTER_SPACE_ID")
+        self.api_key = api_key or getenv("CLICKUP_API_KEY")
+        self.master_space_id = master_space_id or getenv("MASTER_SPACE_ID")
         self.base_url = "https://api.clickup.com/api/v2"
         self.headers = {"Authorization": self.api_key}
 
@@ -37,20 +29,17 @@ class ClickUpTools(Toolkit):
         if not self.master_space_id:
             raise ValueError("MASTER_SPACE_ID not set. Please set the MASTER_SPACE_ID environment variable.")
 
-        if list_tasks:
-            self.register(self.list_tasks)
-        if create_task:
-            self.register(self.create_task)
-        if get_task:
-            self.register(self.get_task)
-        if update_task:
-            self.register(self.update_task)
-        if delete_task:
-            self.register(self.delete_task)
-        if list_spaces:
-            self.register(self.list_spaces)
-        if list_lists:
-            self.register(self.list_lists)
+        tools: List[Any] = [
+            self.list_tasks,
+            self.create_task,
+            self.get_task,
+            self.update_task,
+            self.delete_task,
+            self.list_spaces,
+            self.list_lists,
+        ]
+
+        super().__init__(name="clickup", tools=tools, **kwargs)
 
     def _make_request(
         self, method: str, endpoint: str, params: Optional[Dict] = None, data: Optional[Dict] = None
@@ -175,7 +164,7 @@ class ClickUpTools(Toolkit):
 
         # Get first list in space
         response = self._make_request("GET", f"space/{space['id']}/list")
-        logger.debug(f"Lists: {response}")
+        log_debug(f"Lists: {response}")
         lists_data = response.get("lists", [])
         if not lists_data:
             return json.dumps({"error": f"No lists found in space '{space_name}'"}, indent=2)

agno/tools/confluence.py

@@ -1,9 +1,11 @@
 import json
 from os import getenv
-from typing import Optional
+from typing import Any, List, Optional
+
+import requests
 
 from agno.tools import Toolkit
-from agno.utils.log import logger
+from agno.utils.log import log_info, logger
 
 try:
     from atlassian import Confluence
@@ -18,6 +20,8 @@ class ConfluenceTools(Toolkit):
         password: Optional[str] = None,
         url: Optional[str] = None,
         api_key: Optional[str] = None,
+        verify_ssl: bool = True,
+        **kwargs,
     ):
         """Initialize Confluence Tools with authentication credentials.
 
@@ -26,6 +30,7 @@ class ConfluenceTools(Toolkit):
             password (str, optional): Confluence password. Defaults to None.
             url (str, optional): Confluence instance URL. Defaults to None.
             api_key (str, optional): Confluence API key. Defaults to None.
+            verify_ssl (bool, optional): Whether to verify SSL certificates. Defaults to True.
 
         Notes:
             Credentials can be provided either through method arguments or environment variables:
@@ -34,32 +39,49 @@ class ConfluenceTools(Toolkit):
             - CONFLUENCE_API_KEY
         """
 
-        super().__init__(name="confluence_tools")
         self.url = url or getenv("CONFLUENCE_URL")
         self.username = username or getenv("CONFLUENCE_USERNAME")
         self.password = api_key or getenv("CONFLUENCE_API_KEY") or password or getenv("CONFLUENCE_PASSWORD")
 
         if not self.url:
-            logger.error(
+            raise ValueError(
                 "Confluence URL not provided. Pass it in the constructor or set CONFLUENCE_URL in environment variable"
             )
 
         if not self.username:
-            logger.error(
+            raise ValueError(
                 "Confluence username not provided. Pass it in the constructor or set CONFLUENCE_USERNAME in environment variable"
             )
 
         if not self.password:
-            logger.error("Confluence API KEY or password not provided")
+            raise ValueError("Confluence API KEY or password not provided")
+
+        session = requests.Session()
+        session.verify = verify_ssl
+
+        if not verify_ssl:
+            import urllib3
+
+            urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
+
+        self.confluence = Confluence(
+            url=self.url,
+            username=self.username,
+            password=self.password,
+            verify_ssl=verify_ssl,
+            session=session,
+        )
 
-        self.confluence = Confluence(url=self.url, username=self.username, password=self.password)
+        tools: List[Any] = [
+            self.get_page_content,
+            self.get_space_key,
+            self.create_page,
+            self.update_page,
+            self.get_all_space_detail,
+            self.get_all_page_from_space,
+        ]
 
-        self.register(self.get_page_content)
-        self.register(self.get_space_key)
-        self.register(self.create_page)
-        self.register(self.update_page)
-        self.register(self.get_all_space_detail)
-        self.register(self.get_all_page_from_space)
+        super().__init__(name="confluence_tools", tools=tools, **kwargs)
 
     def get_page_content(self, space_name: str, page_title: str, expand: Optional[str] = "body.storage"):
         """Retrieve the content of a specific page in a Confluence space.
@@ -73,11 +95,14 @@ class ConfluenceTools(Toolkit):
             str: JSON-encoded page content or error message.
         """
         try:
-            logger.info(f"Retrieving page content from space '{space_name}'")
+            log_info(f"Retrieving page content from space '{space_name}'")
             key = self.get_space_key(space_name=space_name)
+            if key == "No space found":
+                return json.dumps({"error": f"Space '{space_name}' not found"})
+
             page = self.confluence.get_page_by_title(key, page_title, expand=expand)
             if page:
-                logger.info(f"Successfully retrieved page '{page_title}' from space '{space_name}'")
+                log_info(f"Successfully retrieved page '{page_title}' from space '{space_name}'")
                 return json.dumps(page)
 
             logger.warning(f"Page '{page_title}' not found in space '{space_name}'")
@@ -93,8 +118,21 @@ class ConfluenceTools(Toolkit):
         Returns:
             str: List of space details as a string.
         """
-        logger.info("Retrieving details for all Confluence spaces")
-        results = self.confluence.get_all_spaces()["results"]
+        log_info("Retrieving details for all Confluence spaces")
+        results = []
+        start = 0
+        limit = 50
+
+        while True:
+            spaces_data = self.confluence.get_all_spaces(start=start, limit=limit)
+            if not spaces_data.get("results"):
+                break
+            results.extend(spaces_data["results"])
+
+            if len(spaces_data["results"]) < limit:
+                break
+            start += limit
+
         return str(results)
 
     def get_space_key(self, space_name: str):
@@ -106,13 +144,29 @@ class ConfluenceTools(Toolkit):
         Returns:
             str: Space key or "No space found" if space doesn't exist.
         """
-        result = self.confluence.get_all_spaces()
-        spaces = result["results"]
+        start = 0
+        limit = 50
 
-        for space in spaces:
-            if space["name"] == space_name:
-                logger.info(f"Found space key for '{space_name}'")
-                return space["key"]
+        while True:
+            result = self.confluence.get_all_spaces(start=start, limit=limit)
+            if not result.get("results"):
+                break
+
+            spaces = result["results"]
+
+            for space in spaces:
+                if space["name"].lower() == space_name.lower():
+                    log_info(f"Found space key for '{space_name}': {space['key']}")
+                    return space["key"]
+
+            for space in spaces:
+                if space["key"] == space_name:
+                    log_info(f"'{space_name}' is already a space key")
+                    return space_name
+
+            if len(spaces) < limit:
+                break
+            start += limit
 
         logger.warning(f"No space named {space_name} found")
         return "No space found"
@@ -126,11 +180,19 @@ class ConfluenceTools(Toolkit):
         Returns:
             list: Details of pages in the specified space.
         """
-        logger.info(f"Retrieving all pages from space '{space_name}'")
+        log_info(f"Retrieving all pages from space '{space_name}'")
         space_key = self.get_space_key(space_name)
+
+        if space_key == "No space found":
+            return json.dumps({"error": f"Space '{space_name}' not found"})
+
         page_details = self.confluence.get_all_pages_from_space(
             space_key, status=None, expand=None, content_type="page"
         )
+
+        if not page_details:
+            return json.dumps({"error": f"No pages found in space '{space_name}'"})
+
         page_details = str([{"id": page["id"], "title": page["title"]} for page in page_details])
         return page_details
 
@@ -148,8 +210,11 @@ class ConfluenceTools(Toolkit):
         """
         try:
             space_key = self.get_space_key(space_name=space_name)
+            if space_key == "No space found":
+                return json.dumps({"error": f"Space '{space_name}' not found"})
+
             page = self.confluence.create_page(space_key, title, body, parent_id=parent_id)
-            logger.info(f"Page created: {title} with ID {page['id']}")
+            log_info(f"Page created: {title} with ID {page['id']}")
             return json.dumps({"id": page["id"], "title": title})
         except Exception as e:
             logger.error(f"Error creating page '{title}': {e}")
@@ -168,7 +233,7 @@ class ConfluenceTools(Toolkit):
         """
         try:
             updated_page = self.confluence.update_page(page_id, title, body)
-            logger.info(f"Page updated: {title} with ID {updated_page['id']}")
+            log_info(f"Page updated: {title} with ID {updated_page['id']}")
             return json.dumps({"status": "success", "id": updated_page["id"]})
         except Exception as e:
             logger.error(f"Error updating page '{title}': {e}")