agno 1.8.0__py3-none-any.whl → 1.8.2__py3-none-any.whl

agno/team/team.py

@@ -157,6 +157,8 @@ class Team:
     add_datetime_to_instructions: bool = False
     # If True, add the current location to the instructions to give the team a sense of location
     add_location_to_instructions: bool = False
+    # Allows for custom timezone for datetime instructions following the TZ Database format (e.g. "Etc/UTC")
+    timezone_identifier: Optional[str] = None
     # If True, add the tools available to team members to the system message
     add_member_tools_to_system_message: bool = True
 
@@ -328,6 +330,7 @@ class Team:
         markdown: bool = False,
         add_datetime_to_instructions: bool = False,
         add_location_to_instructions: bool = False,
+        timezone_identifier: Optional[str] = None,
         add_member_tools_to_system_message: bool = True,
         system_message: Optional[Union[str, Callable, Message]] = None,
         system_message_role: str = "system",
@@ -411,6 +414,7 @@ class Team:
         self.markdown = markdown
         self.add_datetime_to_instructions = add_datetime_to_instructions
         self.add_location_to_instructions = add_location_to_instructions
+        self.timezone_identifier = timezone_identifier
         self.add_member_tools_to_system_message = add_member_tools_to_system_message
         self.system_message = system_message
         self.system_message_role = system_message_role
@@ -5308,7 +5312,19 @@ class Team:
         if self.add_datetime_to_instructions:
             from datetime import datetime
 
-            additional_information.append(f"The current time is {datetime.now()}")
+            tz = None
+
+            if self.timezone_identifier:
+                try:
+                    from zoneinfo import ZoneInfo
+
+                    tz = ZoneInfo(self.timezone_identifier)
+                except Exception:
+                    log_warning("Invalid timezone identifier")
+
+            time = datetime.now(tz) if tz else datetime.now()
+
+            additional_information.append(f"The current time is {time}.")
 
         # 1.3.3 Add the current location
         if self.add_location_to_instructions:

agno/tools/confluence.py

@@ -2,6 +2,8 @@ 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
 
@@ -55,14 +57,22 @@ class ConfluenceTools(Toolkit):
         if not self.password:
             raise ValueError("Confluence API KEY or password not provided")
 
-        self.confluence = Confluence(
-            url=self.url, username=self.username, password=self.password, verify_ssl=verify_ssl
-        )
+        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] = []
         tools.append(self.get_page_content)
         tools.append(self.get_space_key)
@@ -87,6 +97,9 @@ class ConfluenceTools(Toolkit):
         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}'")
@@ -106,7 +119,20 @@ class ConfluenceTools(Toolkit):
             str: List of space details as a string.
         """
         log_info("Retrieving details for all Confluence spaces")
-        results = self.confluence.get_all_spaces()["results"]
+        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):
@@ -118,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
+
+        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
 
-        for space in spaces:
-            if space["name"] == space_name:
-                log_info(f"Found space key for '{space_name}'")
-                return space["key"]
+            if len(spaces) < limit:
+                break
+            start += limit
 
         logger.warning(f"No space named {space_name} found")
         return "No space found"
@@ -140,9 +182,17 @@ class ConfluenceTools(Toolkit):
         """
         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
 
@@ -160,6 +210,9 @@ 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)
             log_info(f"Page created: {title} with ID {page['id']}")
             return json.dumps({"id": page["id"], "title": title})

agno/tools/e2b.py

@@ -58,7 +58,7 @@ class E2BTools(Toolkit):
 
         # According to official docs, the parameter is 'timeout' (in seconds), not 'timeout_ms'
         try:
-            self.sandbox = Sandbox(api_key=self.api_key, timeout=timeout, **self.sandbox_options)
+            self.sandbox = Sandbox.create(api_key=self.api_key, timeout=timeout, **self.sandbox_options)
         except Exception as e:
             logger.error(f"Warning: Could not create sandbox: {e}")
             raise e

agno/tools/firecrawl.py

@@ -6,7 +6,8 @@ from agno.tools import Toolkit
 from agno.utils.log import logger
 
 try:
-    from firecrawl import FirecrawlApp, ScrapeOptions  # type: ignore[attr-defined]
+    from firecrawl import FirecrawlApp  # type: ignore[attr-defined]
+    from firecrawl.types import ScrapeOptions
 except ImportError:
     raise ImportError("`firecrawl-py` not installed. Please install using `pip install firecrawl-py`")
 
@@ -87,7 +88,7 @@ class FirecrawlTools(Toolkit):
         if self.formats:
             params["formats"] = self.formats
 
-        scrape_result = self.app.scrape_url(url, **params)
+        scrape_result = self.app.scrape(url, **params)
         return json.dumps(scrape_result.model_dump(), cls=CustomJSONEncoder)
 
     def crawl_website(self, url: str, limit: Optional[int] = None) -> str:
@@ -108,7 +109,7 @@ class FirecrawlTools(Toolkit):
 
         params["poll_interval"] = self.poll_interval
 
-        crawl_result = self.app.crawl_url(url, **params)
+        crawl_result = self.app.crawl(url, **params)
         return json.dumps(crawl_result.model_dump(), cls=CustomJSONEncoder)
 
     def map_website(self, url: str) -> str:
@@ -118,7 +119,7 @@ class FirecrawlTools(Toolkit):
             url (str): The URL to map.
 
         """
-        map_result = self.app.map_url(url)
+        map_result = self.app.map(url)
         return json.dumps(map_result.model_dump(), cls=CustomJSONEncoder)
 
     def search(self, query: str, limit: Optional[int] = None):

agno/tools/gmail.py

@@ -133,7 +133,7 @@ class GmailTools(Toolkit):
             send_email (bool): Enable sending emails. Defaults to True.
             search_emails (bool): Enable searching emails. Defaults to True.
             send_email_reply (bool): Enable sending email replies. Defaults to True.
-            creds (Optional[Credentials]): Pre-existing credentials. Defaults to None.
+            creds (Optional[Credentials]): Pre-fetched OAuth credentials. Use this to skip a new auth flow. Defaults to None.
             credentials_path (Optional[str]): Path to credentials file. Defaults to None.
             token_path (Optional[str]): Path to token file. Defaults to None.
             scopes (Optional[List[str]]): Custom OAuth scopes. If None, uses DEFAULT_SCOPES.

agno/tools/linear.py

@@ -217,7 +217,7 @@ class LinearTools(Toolkit):
         """
 
         query = """
-        mutation IssueCreate ($title: String!, $description: String!, $teamId: String!, $projectId: String!, $assigneeId: String!){
+        mutation IssueCreate ($title: String!, $description: String!, $teamId: String!, $projectId: String, $assigneeId: String){
           issueCreate(
             input: { title: $title, description: $description, teamId: $teamId, projectId: $projectId, assigneeId: $assigneeId}
           ) {

agno/tools/neo4j.py

@@ -0,0 +1,132 @@
+import os
+from typing import Any, List, Optional
+
+try:
+    from neo4j import GraphDatabase
+except ImportError:
+    raise ImportError("`neo4j` not installed. Please install using `pip install neo4j`")
+
+from agno.tools import Toolkit
+from agno.utils.log import log_debug, logger
+
+
+class Neo4jTools(Toolkit):
+    def __init__(
+        self,
+        uri: Optional[str] = None,
+        user: Optional[str] = None,
+        password: Optional[str] = None,
+        database: Optional[str] = None,
+        list_labels: bool = True,
+        list_relationships: bool = True,
+        get_schema: bool = True,
+        run_cypher: bool = True,
+        **kwargs,
+    ):
+        """
+        Initialize the Neo4jTools toolkit.
+        Connection parameters (uri/user/password or host/port) can be provided.
+        If not provided, falls back to NEO4J_URI, NEO4J_USERNAME, NEO4J_PASSWORD env vars.
+
+        Args:
+            uri (Optional[str]): The Neo4j URI.
+            user (Optional[str]): The Neo4j username.
+            password (Optional[str]): The Neo4j password.
+            host (Optional[str]): The Neo4j host.
+            port (Optional[int]): The Neo4j port.
+            database (Optional[str]): The Neo4j database.
+            list_labels (bool): Whether to list node labels.
+            list_relationships (bool): Whether to list relationship types.
+            get_schema (bool): Whether to get the schema.
+            run_cypher (bool): Whether to run Cypher queries.
+            **kwargs: Additional keyword arguments.
+        """
+        # Determine the connection URI and credentials
+        uri = uri or os.getenv("NEO4J_URI", "bolt://localhost:7687")
+        user = user or os.getenv("NEO4J_USERNAME")
+        password = password or os.getenv("NEO4J_PASSWORD")
+
+        if user is None or password is None:
+            raise ValueError("Username or password for Neo4j not provided")
+
+        # Create the Neo4j driver
+        try:
+            self.driver = GraphDatabase.driver(uri, auth=(user, password))  # type: ignore
+            self.driver.verify_connectivity()
+            log_debug("Connected to Neo4j database")
+        except Exception as e:
+            logger.error(f"Failed to connect to Neo4j: {e}")
+            raise
+
+        self.database = database or "neo4j"
+
+        # Register toolkit methods as tools
+        tools: List[Any] = []
+        if list_labels:
+            tools.append(self.list_labels)
+        if list_relationships:
+            tools.append(self.list_relationship_types)
+        if get_schema:
+            tools.append(self.get_schema)
+        if run_cypher:
+            tools.append(self.run_cypher_query)
+        super().__init__(name="neo4j_tools", tools=tools, **kwargs)
+
+    def list_labels(self) -> list:
+        """
+        Retrieve all node labels present in the connected Neo4j database.
+        """
+        try:
+            log_debug("Listing node labels in Neo4j database")
+            with self.driver.session(database=self.database) as session:
+                result = session.run("CALL db.labels()")
+                labels = [record["label"] for record in result]
+            return labels
+        except Exception as e:
+            logger.error(f"Error listing labels: {e}")
+            return []
+
+    def list_relationship_types(self) -> list:
+        """
+        Retrieve all relationship types present in the connected Neo4j database.
+        """
+        try:
+            log_debug("Listing relationship types in Neo4j database")
+            with self.driver.session(database=self.database) as session:
+                result = session.run("CALL db.relationshipTypes()")
+                types = [record["relationshipType"] for record in result]
+            return types
+        except Exception as e:
+            logger.error(f"Error listing relationship types: {e}")
+            return []
+
+    def get_schema(self) -> list:
+        """
+        Retrieve a visualization of the database schema, including nodes and relationships.
+        """
+        try:
+            log_debug("Retrieving Neo4j schema visualization")
+            with self.driver.session(database=self.database) as session:
+                result = session.run("CALL db.schema.visualization()")
+                schema_data = result.data()
+            return schema_data
+        except Exception as e:
+            logger.error(f"Error getting Neo4j schema: {e}")
+            return []
+
+    def run_cypher_query(self, query: str) -> list:
+        """
+        Execute an arbitrary Cypher query against the connected Neo4j database.
+
+        Args:
+            query (str): The Cypher query string to execute.
+        """
+        try:
+            log_debug(f"Running Cypher query: {query}")
+            with self.driver.session(database=self.database) as session:
+                result = session.run(query)  # type: ignore[arg-type]
+                data = result.data()
+            return data
+        except Exception as e:
+            logger.error(f"Error running Cypher query: {e}")
+            return []

agno/utils/gemini.py

@@ -175,7 +175,37 @@ def convert_schema(schema_dict: Dict[str, Any], root_schema: Optional[Dict[str,
 
     elif schema_type == "array" and "items" in schema_dict:
         items = convert_schema(schema_dict["items"], root_schema)
-        return Schema(type=Type.ARRAY, description=description, items=items)
+        min_items = schema_dict.get("minItems")
+        max_items = schema_dict.get("maxItems")
+        return Schema(
+            type=Type.ARRAY,
+            description=description,
+            items=items,
+            min_items=min_items,
+            max_items=max_items,
+        )
+
+    elif schema_type == "string":
+        schema_kwargs = {
+            "type": Type.STRING,
+            "description": description,
+            "default": default,
+        }
+        if "format" in schema_dict:
+            schema_kwargs["format"] = schema_dict["format"]
+        return Schema(**schema_kwargs)
+
+    elif schema_type in ("integer", "number"):
+        schema_kwargs = {
+            "type": schema_type.upper(),
+            "description": description,
+            "default": default,
+        }
+        if "maximum" in schema_dict:
+            schema_kwargs["maximum"] = schema_dict["maximum"]
+        if "minimum" in schema_dict:
+            schema_kwargs["minimum"] = schema_dict["minimum"]
+        return Schema(**schema_kwargs)
 
     elif schema_type == "" and "anyOf" in schema_dict:
         any_of = []

agno/utils/location.py

@@ -10,10 +10,10 @@ def get_location() -> Dict[str, Any]:
     try:
         response = requests.get("https://api.ipify.org?format=json", timeout=5)
         ip = response.json()["ip"]
-        response = requests.get(f"https://ipapi.co/{ip}/json/", timeout=5)
+        response = requests.get(f"http://ip-api.com/json/{ip}", timeout=5)
         if response.status_code == 200:
             data = response.json()
-            return {"city": data.get("city"), "region": data.get("region"), "country": data.get("country_name")}
+            return {"city": data.get("city"), "region": data.get("region"), "country": data.get("country")}
     except Exception as e:
         log_warning(f"Failed to get location: {e}")
     return {}

agno/utils/models/claude.py

@@ -284,3 +284,52 @@ def format_messages(messages: List[Message]) -> Tuple[List[Dict[str, str]], str]
 
         chat_messages.append({"role": ROLE_MAP[message.role], "content": content})  # type: ignore
     return chat_messages, " ".join(system_messages)
+
+
+def format_tools_for_model(tools: Optional[List[Dict[str, Any]]] = None) -> Optional[List[Dict[str, Any]]]:
+    """
+    Transforms function definitions into a format accepted by the Anthropic API.
+    """
+    if not tools:
+        return None
+
+    parsed_tools: List[Dict[str, Any]] = []
+    for tool_def in tools:
+        if tool_def.get("type", "") != "function":
+            parsed_tools.append(tool_def)
+            continue
+
+        func_def = tool_def.get("function", {})
+        parameters: Dict[str, Any] = func_def.get("parameters", {})
+        properties: Dict[str, Any] = parameters.get("properties", {})
+        required: List[str] = parameters.get("required", [])
+        required_params: List[str] = required
+
+        if not required_params:
+            for param_name, param_info in properties.items():
+                param_type = param_info.get("type", "")
+                param_type_list: List[str] = [param_type] if isinstance(param_type, str) else param_type or []
+
+                if "null" not in param_type_list:
+                    required_params.append(param_name)
+
+        input_properties: Dict[str, Any] = {}
+        for param_name, param_info in properties.items():
+            # Preserve the complete schema structure for complex types
+            input_properties[param_name] = param_info.copy()
+
+            # Ensure description is present (default to empty if missing)
+            if "description" not in input_properties[param_name]:
+                input_properties[param_name]["description"] = ""
+
+        tool = {
+            "name": func_def.get("name") or "",
+            "description": func_def.get("description") or "",
+            "input_schema": {
+                "type": parameters.get("type", "object"),
+                "properties": input_properties,
+                "required": required_params,
+            },
+        }
+        parsed_tools.append(tool)
+    return parsed_tools

agno/vectordb/qdrant/qdrant.py

@@ -704,3 +704,25 @@ class Qdrant(VectorDb):
 
     def delete(self) -> bool:
         return self.client.delete_collection(collection_name=self.collection)
+
+    def close(self) -> None:
+        """Close the Qdrant client connections."""
+        if self._client is not None:
+            try:
+                self._client.close()
+                log_debug("Qdrant client closed successfully")
+            except Exception as e:
+                log_debug(f"Error closing Qdrant client: {e}")
+            finally:
+                self._client = None
+
+    async def async_close(self) -> None:
+        """Close the Qdrant client connections asynchronously."""
+        if self._async_client is not None:
+            try:
+                await self._async_client.close()
+                log_debug("Async Qdrant client closed successfully")
+            except Exception as e:
+                log_debug(f"Error closing async Qdrant client: {e}")
+            finally:
+                self._async_client = None

agno/workflow/v2/workflow.py

@@ -3273,7 +3273,8 @@ class Workflow:
         """Update executor with workflow_session_state"""
         if self.workflow_session_state is not None:
             # Update session_state with workflow_session_state
-            executor.workflow_session_state = self.workflow_session_state
+            if hasattr(executor, "workflow_session_state"):
+                executor.workflow_session_state = self.workflow_session_state
 
     def _save_run_to_storage(self, workflow_run_response: WorkflowRunResponse) -> None:
         """Helper method to save workflow run response to storage"""

{agno-1.8.0.dist-info → agno-1.8.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agno
-Version: 1.8.0
+Version: 1.8.2
 Summary: Agno: a lightweight library for building Multi-Agent Systems
 Author-email: Ashpreet Bedi <ashpreet@agno.com>
 License: Copyright (c) Agno, Inc.
@@ -553,6 +553,8 @@ Provides-Extra: oxylabs
 Requires-Dist: oxylabs; extra == "oxylabs"
 Provides-Extra: trafilatura
 Requires-Dist: trafilatura; extra == "trafilatura"
+Provides-Extra: neo4j
+Requires-Dist: neo4j; extra == "neo4j"
 Provides-Extra: sql
 Requires-Dist: sqlalchemy; extra == "sql"
 Provides-Extra: postgres
@@ -670,6 +672,7 @@ Requires-Dist: agno[memori]; extra == "tools"
 Requires-Dist: agno[google_bigquery]; extra == "tools"
 Requires-Dist: agno[psycopg]; extra == "tools"
 Requires-Dist: agno[trafilatura]; extra == "tools"
+Requires-Dist: agno[neo4j]; extra == "tools"
 Provides-Extra: storage
 Requires-Dist: agno[sql]; extra == "storage"
 Requires-Dist: agno[postgres]; extra == "storage"