agno 2.2.13__py3-none-any.whl

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.py

@@ -0,0 +1,244 @@
+import json
+import re
+from os import getenv
+from typing import Any, Dict, List, Optional
+
+from agno.tools import Toolkit
+from agno.utils.log import log_debug, logger
+
+try:
+    import requests
+except ImportError:
+    raise ImportError("`requests` not installed. Please install using `pip install requests`")
+
+
+class ClickUpTools(Toolkit):
+    def __init__(
+        self,
+        api_key: Optional[str] = None,
+        master_space_id: Optional[str] = None,
+        **kwargs,
+    ):
+        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}
+
+        if not self.api_key:
+            raise ValueError("CLICKUP_API_KEY not set. Please set the CLICKUP_API_KEY environment variable.")
+        if not self.master_space_id:
+            raise ValueError("MASTER_SPACE_ID not set. Please set the MASTER_SPACE_ID environment variable.")
+
+        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
+    ) -> Dict[str, Any]:
+        """Make a request to the ClickUp API."""
+        url = f"{self.base_url}/{endpoint}"
+        try:
+            response = requests.request(method=method, url=url, headers=self.headers, params=params, json=data)
+            response.raise_for_status()
+            return response.json()
+        except requests.exceptions.RequestException as e:
+            logger.error(f"Error making request to {url}: {e}")
+            return {"error": str(e)}
+
+    def _find_by_name(self, items: List[Dict[str, Any]], name: str) -> Optional[Dict[str, Any]]:
+        """Find an item in a list by name using exact match or regex pattern.
+
+        Args:
+            items: List of items to search through
+            name: Name to search for
+
+        Returns:
+            Matching item or None if not found
+        """
+        if not name:
+            return items[0] if items else None
+
+        pattern = re.compile(name, re.IGNORECASE)
+        for item in items:
+            # Try exact match first (case-insensitive)
+            if item["name"].lower() == name.lower():
+                return item
+            # Then try regex pattern match
+            if pattern.search(item["name"]):
+                return item
+        return None
+
+    def _get_space(self, space_name: str) -> Dict[str, Any]:
+        """Get space information by name."""
+        spaces = self._make_request("GET", f"team/{self.master_space_id}/space")
+        if "error" in spaces:
+            return spaces
+
+        spaces_list = spaces.get("spaces", [])
+        if not spaces_list:
+            return {"error": "No spaces found"}
+
+        space = self._find_by_name(spaces_list, space_name)
+        if not space:
+            return {"error": f"Space '{space_name}' not found"}
+        return space
+
+    def _get_list(self, space_id: str, list_name: str) -> Dict[str, Any]:
+        """Get list information by name."""
+        lists = self._make_request("GET", f"space/{space_id}/list")
+        if "error" in lists:
+            return lists
+
+        lists_data = lists.get("lists", [])
+        if not lists_data:
+            return {"error": "No lists found in space"}
+
+        list_item = self._find_by_name(lists_data, list_name)
+        if not list_item:
+            return {"error": f"List '{list_name}' not found"}
+        return list_item
+
+    def _get_tasks(self, list_id: str) -> List[Dict[str, Any]]:
+        """Get tasks in a list, optionally filtered by name."""
+        tasks = self._make_request("GET", f"list/{list_id}/task")
+        if "error" in tasks:
+            return []
+
+        tasks_data = tasks.get("tasks", [])
+        return tasks_data
+
+    def list_tasks(self, space_name: str) -> str:
+        """List all tasks in a space.
+
+        Args:
+            space_name (str): Name of the space to list tasks from
+
+        Returns:
+            str: JSON string containing tasks
+        """
+        # Get space
+        space = self._get_space(space_name)
+        if "error" in space:
+            return json.dumps(space, indent=2)
+
+        # Get lists
+        lists = self._make_request("GET", f"space/{space['id']}/list")
+        lists_data = lists.get("lists", [])
+        if not lists_data:
+            return json.dumps({"error": f"No lists found in space '{space_name}'"}, indent=2)
+
+        # Get tasks from all lists
+        all_tasks = []
+        for list_info in lists_data:
+            tasks = self._get_tasks(list_info["id"])
+            for task in tasks:
+                task["list_name"] = list_info["name"]  # Add list name for context
+            all_tasks.extend(tasks)
+
+        return json.dumps({"tasks": all_tasks}, indent=2)
+
+    def create_task(self, space_name: str, task_name: str, task_description: str) -> str:
+        """Create a new task in a space.
+
+        Args:
+            space_name (str): Name of the space to create task in
+            task_name (str): Name of the task
+            task_description (str): Description of the task
+
+        Returns:
+            str: JSON string containing created task details
+        """
+        # Get space
+        space = self._get_space(space_name)
+        if "error" in space:
+            return json.dumps(space, indent=2)
+
+        # Get first list in space
+        response = self._make_request("GET", f"space/{space['id']}/list")
+        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)
+
+        list_info = lists_data[0]  # Use first list
+
+        # Create task
+        data = {"name": task_name, "description": task_description}
+
+        task = self._make_request("POST", f"list/{list_info['id']}/task", data=data)
+        return json.dumps(task, indent=2)
+
+    def list_spaces(self) -> str:
+        """List all spaces in the workspace.
+
+        Returns:
+            str: JSON string containing list of spaces
+        """
+        spaces = self._make_request("GET", f"team/{self.master_space_id}/space")
+        return json.dumps(spaces, indent=2)
+
+    def list_lists(self, space_name: str) -> str:
+        """List all lists in a space.
+
+        Args:
+            space_name (str): Name of the space to list lists from
+
+        Returns:
+            str: JSON string containing list of lists
+        """
+        # Get space
+        space = self._get_space(space_name)
+        if "error" in space:
+            return json.dumps(space, indent=2)
+
+        # Get lists
+        lists = self._make_request("GET", f"space/{space['id']}/list")
+        return json.dumps(lists, indent=2)
+
+    def get_task(self, task_id: str) -> str:
+        """Get details of a specific task.
+
+        Args:
+            task_id (str): The ID of the task
+
+        Returns:
+            str: JSON string containing task details
+        """
+        task = self._make_request("GET", f"task/{task_id}")
+        return json.dumps(task, indent=2)
+
+    def update_task(self, task_id: str, **kwargs) -> str:
+        """Update a specific task.
+
+        Args:
+            task_id (str): The ID of the task
+            **kwargs: Task fields to update (name, description, status, priority, etc.)
+
+        Returns:
+            str: JSON string containing updated task details
+        """
+        task = self._make_request("PUT", f"task/{task_id}", data=kwargs)
+        return json.dumps(task, indent=2)
+
+    def delete_task(self, task_id: str) -> str:
+        """Delete a specific task.
+
+        Args:
+            task_id (str): The ID of the task
+
+        Returns:
+            str: JSON string containing deletion status
+        """
+        result = self._make_request("DELETE", f"task/{task_id}")
+        if "error" not in result:
+            result = {"success": True, "message": f"Task {task_id} deleted successfully"}
+        return json.dumps(result, indent=2)

agno/tools/confluence.py

@@ -0,0 +1,240 @@
+import json
+from os import getenv
+from typing import Any, List, Optional
+
+import requests
+
+from agno.tools import Toolkit
+from agno.utils.log import log_info, logger
+
+try:
+    from atlassian import Confluence
+except (ModuleNotFoundError, ImportError):
+    raise ImportError("atlassian-python-api not install . Please install using `pip install atlassian-python-api`")
+
+
+class ConfluenceTools(Toolkit):
+    def __init__(
+        self,
+        username: Optional[str] = None,
+        password: Optional[str] = None,
+        url: Optional[str] = None,
+        api_key: Optional[str] = None,
+        verify_ssl: bool = True,
+        **kwargs,
+    ):
+        """Initialize Confluence Tools with authentication credentials.
+
+        Args:
+            username (str, optional): Confluence username. Defaults to None.
+            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:
+            - CONFLUENCE_URL
+            - CONFLUENCE_USERNAME
+            - CONFLUENCE_API_KEY
+        """
+
+        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:
+            raise ValueError(
+                "Confluence URL not provided. Pass it in the constructor or set CONFLUENCE_URL in environment variable"
+            )
+
+        if not self.username:
+            raise ValueError(
+                "Confluence username not provided. Pass it in the constructor or set CONFLUENCE_USERNAME in environment variable"
+            )
+
+        if not self.password:
+            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,
+        )
+
+        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,
+        ]
+
+        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.
+
+        Args:
+            space_name (str): Name of the Confluence space.
+            page_title (str): Title of the page to retrieve.
+            expand (str, optional): Fields to expand in the page response. Defaults to "body.storage".
+
+        Returns:
+            str: JSON-encoded page content or error message.
+        """
+        try:
+            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:
+                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}'")
+            return json.dumps({"error": f"Page '{page_title}' not found in space '{space_name}'"})
+
+        except Exception as e:
+            logger.error(f"Error retrieving page '{page_title}': {e}")
+            return json.dumps({"error": str(e)})
+
+    def get_all_space_detail(self):
+        """Retrieve details about all Confluence spaces.
+
+        Returns:
+            str: List of space details as a string.
+        """
+        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):
+        """Get the space key for a particular Confluence space.
+
+        Args:
+            space_name (str): Name of the space whose key is required.
+
+        Returns:
+            str: Space key or "No space found" if space doesn't exist.
+        """
+        start = 0
+        limit = 50
+
+        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"
+
+    def get_all_page_from_space(self, space_name: str):
+        """Retrieve all pages from a specific Confluence space.
+
+        Args:
+            space_name (str): Name of the Confluence space.
+
+        Returns:
+            list: Details of pages in the specified space.
+        """
+        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
+
+    def create_page(self, space_name: str, title: str, body: str, parent_id: Optional[str] = None) -> str:
+        """Create a new page in Confluence.
+
+        Args:
+            space_name (str): Name of the Confluence space.
+            title (str): Title of the new page.
+            body (str): Content of the new page.
+            parent_id (str, optional): ID of the parent page if creating a child page. Defaults to None.
+
+        Returns:
+            str: JSON-encoded page ID and title or error message.
+        """
+        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)
+            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}")
+            return json.dumps({"error": str(e)})
+
+    def update_page(self, page_id: str, title: str, body: str) -> str:
+        """Update an existing Confluence page.
+
+        Args:
+            page_id (str): ID of the page to update.
+            title (str): New title for the page.
+            body (str): Updated content for the page.
+
+        Returns:
+            str: JSON-encoded status and ID of the updated page or error message.
+        """
+        try:
+            updated_page = self.confluence.update_page(page_id, title, body)
+            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}")
+            return json.dumps({"error": str(e)})