agno 1.7.10__py3-none-any.whl → 1.7.11__py3-none-any.whl

agno/storage/in_memory.py

@@ -0,0 +1,234 @@
+import time
+from dataclasses import asdict
+from typing import Dict, List, Literal, Optional
+
+from agno.storage.base import Storage
+from agno.storage.session import Session
+from agno.storage.session.agent import AgentSession
+from agno.storage.session.team import TeamSession
+from agno.storage.session.v2.workflow import WorkflowSession as WorkflowSessionV2
+from agno.storage.session.workflow import WorkflowSession
+from agno.utils.log import logger
+
+
+class InMemoryStorage(Storage):
+    def __init__(
+        self,
+        mode: Optional[Literal["agent", "team", "workflow", "workflow_v2"]] = "agent",
+        storage_dict: Optional[Dict[str, Dict]] = None,
+    ):
+        super().__init__(mode)
+        self.storage: Dict[str, Dict] = storage_dict if storage_dict is not None else {}
+
+    def create(self) -> None:
+        """Create the storage if it doesn't exist."""
+        # No-op for in-memory storage
+        pass
+
+    def read(self, session_id: str, user_id: Optional[str] = None) -> Optional[Session]:
+        """Read a Session from storage."""
+        try:
+            data = self.storage.get(session_id)
+            if data is None:
+                return None
+            if user_id and data["user_id"] != user_id:
+                return None
+            if self.mode == "agent":
+                return AgentSession.from_dict(data)
+            elif self.mode == "team":
+                return TeamSession.from_dict(data)
+            elif self.mode == "workflow":
+                return WorkflowSession.from_dict(data)
+            elif self.mode == "workflow_v2":
+                return WorkflowSessionV2.from_dict(data)
+
+        except Exception as e:
+            logger.error(f"Error reading session {session_id}: {e}")
+            return None
+
+    def get_all_session_ids(self, user_id: Optional[str] = None, entity_id: Optional[str] = None) -> List[str]:
+        """Get all session IDs, optionally filtered by user_id and/or entity_id."""
+        session_ids = []
+        for _, data in self.storage.items():
+            if user_id or entity_id:
+                if user_id and entity_id:
+                    if self.mode == "agent" and data["agent_id"] == entity_id and data["user_id"] == user_id:
+                        session_ids.append(data["session_id"])
+                    elif self.mode == "team" and data["team_id"] == entity_id and data["user_id"] == user_id:
+                        session_ids.append(data["session_id"])
+                    elif self.mode == "workflow" and data["workflow_id"] == entity_id and data["user_id"] == user_id:
+                        session_ids.append(data["session_id"])
+
+                elif user_id and data["user_id"] == user_id:
+                    session_ids.append(data["session_id"])
+
+                elif entity_id:
+                    if self.mode == "agent" and data["agent_id"] == entity_id:
+                        session_ids.append(data["session_id"])
+                    elif self.mode == "team" and data["team_id"] == entity_id:
+                        session_ids.append(data["session_id"])
+                    elif self.mode == "workflow" and data["workflow_id"] == entity_id:
+                        session_ids.append(data["session_id"])
+                    elif self.mode == "workflow_v2" and data["workflow_id"] == entity_id:
+                        session_ids.append(data["session_id"])
+
+            else:
+                # No filters applied, add all session_ids
+                session_ids.append(data["session_id"])
+
+        return session_ids
+
+    def get_all_sessions(self, user_id: Optional[str] = None, entity_id: Optional[str] = None) -> List[Session]:
+        """Get all sessions, optionally filtered by user_id and/or entity_id."""
+        sessions: List[Session] = []
+        for _, data in self.storage.items():
+            if user_id or entity_id:
+                _session: Optional[Session] = None
+
+                if user_id and entity_id:
+                    if self.mode == "agent" and data["agent_id"] == entity_id and data["user_id"] == user_id:
+                        _session = AgentSession.from_dict(data)
+                    elif self.mode == "team" and data["team_id"] == entity_id and data["user_id"] == user_id:
+                        _session = TeamSession.from_dict(data)
+                    elif self.mode == "workflow" and data["workflow_id"] == entity_id and data["user_id"] == user_id:
+                        _session = WorkflowSession.from_dict(data)
+
+                elif user_id and data["user_id"] == user_id:
+                    if self.mode == "agent":
+                        _session = AgentSession.from_dict(data)
+                    elif self.mode == "team":
+                        _session = TeamSession.from_dict(data)
+                    elif self.mode == "workflow":
+                        _session = WorkflowSession.from_dict(data)
+
+                elif entity_id:
+                    if self.mode == "agent" and data["agent_id"] == entity_id:
+                        _session = AgentSession.from_dict(data)
+                    elif self.mode == "team" and data["team_id"] == entity_id:
+                        _session = TeamSession.from_dict(data)
+                    elif self.mode == "workflow" and data["workflow_id"] == entity_id:
+                        _session = WorkflowSession.from_dict(data)
+                    elif self.mode == "workflow_v2" and data["workflow_id"] == entity_id:
+                        _session = WorkflowSessionV2.from_dict(data)
+
+                if _session:
+                    sessions.append(_session)
+
+            else:
+                # No filters applied, add all sessions
+                if self.mode == "agent":
+                    _session = AgentSession.from_dict(data)
+                elif self.mode == "team":
+                    _session = TeamSession.from_dict(data)
+                elif self.mode == "workflow":
+                    _session = WorkflowSession.from_dict(data)
+                elif self.mode == "workflow_v2":
+                    _session = WorkflowSessionV2.from_dict(data)
+
+                if _session:
+                    sessions.append(_session)
+
+        return sessions
+
+    def get_recent_sessions(
+        self,
+        user_id: Optional[str] = None,
+        entity_id: Optional[str] = None,
+        limit: Optional[int] = 2,
+    ) -> List[Session]:
+        """Get the last N sessions, ordered by created_at descending.
+
+        Args:
+            limit: Number of most recent sessions to return
+            user_id: Filter by user ID
+            entity_id: Filter by entity ID (agent_id, team_id, or workflow_id)
+
+        Returns:
+            List[Session]: List of most recent sessions
+        """
+        sessions: List[Session] = []
+        # List of (created_at, data) tuples for sorting
+        session_data: List[tuple[int, dict]] = []
+
+        # First pass: collect and filter sessions
+        for session_id, data in self.storage.items():
+            try:
+                if user_id and data["user_id"] != user_id:
+                    continue
+
+                if entity_id:
+                    if self.mode == "agent" and data["agent_id"] != entity_id:
+                        continue
+                    elif self.mode == "team" and data["team_id"] != entity_id:
+                        continue
+                    elif self.mode == "workflow" and data["workflow_id"] != entity_id:
+                        continue
+                    elif self.mode == "workflow_v2" and data["workflow_id"] != entity_id:
+                        continue
+
+                # Store with created_at for sorting
+                created_at = data.get("created_at", 0)
+                session_data.append((created_at, data))
+
+            except Exception as e:
+                logger.error(f"Error processing session {session_id}: {e}")
+                continue
+
+        # Sort by created_at descending and take only limit sessions
+        session_data.sort(key=lambda x: x[0], reverse=True)
+        if limit is not None:
+            session_data = session_data[:limit]
+
+        # Convert filtered and sorted data to Session objects
+        for _, data in session_data:
+            session: Optional[Session] = None
+            if self.mode == "agent":
+                session = AgentSession.from_dict(data)
+            elif self.mode == "team":
+                session = TeamSession.from_dict(data)
+            elif self.mode == "workflow":
+                session = WorkflowSession.from_dict(data)
+            elif self.mode == "workflow_v2":
+                session = WorkflowSessionV2.from_dict(data)
+            if session is not None:
+                sessions.append(session)
+
+        return sessions
+
+    def upsert(self, session: Session) -> Optional[Session]:
+        """Insert or update a Session in storage."""
+        try:
+            if self.mode == "workflow_v2":
+                data = session.to_dict()
+            else:
+                data = asdict(session)
+
+            data["updated_at"] = int(time.time())
+            if not data.get("created_at", None):
+                data["created_at"] = data["updated_at"]
+
+            self.storage[session.session_id] = data
+            return session
+
+        except Exception as e:
+            logger.error(f"Error upserting session: {e}")
+            return None
+
+    def delete_session(self, session_id: Optional[str] = None):
+        """Delete a session from storage."""
+        if session_id is None:
+            return
+
+        try:
+            self.storage.pop(session_id, None)
+
+        except Exception as e:
+            logger.error(f"Error deleting session: {e}")
+
+    def drop(self) -> None:
+        """Drop all sessions from storage."""
+        self.storage.clear()
+
+    def upgrade_schema(self) -> None:
+        """Upgrade the schema of the storage."""
+        pass

agno/team/team.py

@@ -1353,6 +1353,10 @@ class Team:
                         **kwargs,
                     )
 
+                self.run_messages = run_messages
+                if len(run_messages.messages) == 0:
+                    log_error("No messages to be sent to the model.")
+
                 if stream:
                     response_iterator = self._arun_stream(
                         run_response=self.run_response,
@@ -5339,7 +5343,7 @@ class Team:
         system_message_content += "\n<how_to_respond>\n"
         if self.mode == "coordinate":
             system_message_content += (
-                "- You can either respond directly or transfer tasks to members in your team with the highest likelihood of completing the user's request.\n"
+                "- Your role is to forward tasks to members in your team with the highest likelihood of completing the user's request.\n"
                 "- Carefully analyze the tools available to the members and their roles before transferring tasks.\n"
                 "- You cannot use a member tool directly. You can only transfer tasks to members.\n"
                 "- When you transfer a task to another member, make sure to include:\n"
@@ -5350,15 +5354,19 @@ class Team:
                 "- You must always analyze the responses from members before responding to the user.\n"
                 "- After analyzing the responses from the members, if you feel the task has been completed, you can stop and respond to the user.\n"
                 "- If you are not satisfied with the responses from the members, you should re-assign the task.\n"
+                "- For simple greetings, thanks, or questions about the team itself, you should respond directly.\n"
+                "- For all work requests, tasks, or questions requiring expertise, route to appropriate team members.\n"
             )
         elif self.mode == "route":
             system_message_content += (
-                "- You can either respond directly or forward tasks to members in your team with the highest likelihood of completing the user's request.\n"
+                "- Your role is to forward tasks to members in your team with the highest likelihood of completing the user's request.\n"
                 "- Carefully analyze the tools available to the members and their roles before forwarding tasks.\n"
                 "- When you forward a task to another Agent, make sure to include:\n"
                 "  - member_id (str): The ID of the member to forward the task to. Use only the ID of the member, not the ID of the team followed by the ID of the member.\n"
                 "  - expected_output (str): The expected output.\n"
                 "- You can forward tasks to multiple members at once.\n"
+                "- For simple greetings, thanks, or questions about the team itself, you should respond directly.\n"
+                "- For all work requests, tasks, or questions requiring expertise, route to appropriate team members.\n"
             )
         elif self.mode == "collaborate":
             system_message_content += (

agno/tools/brandfetch.py

@@ -0,0 +1,210 @@
+"""
+Going to contribute this to agno toolkits.
+"""
+
+from os import getenv
+from typing import Any, Optional
+
+try:
+    import httpx
+except ImportError:
+    raise ImportError("`httpx` not installed.")
+
+from agno.tools import Toolkit
+
+
+class BrandfetchTools(Toolkit):
+    """
+    Brandfetch API toolkit for retrieving brand data and searching brands.
+
+    Supports both Brand API (retrieve comprehensive brand data) and
+    Brand Search API (find and search brands by name).
+
+    -- Brand API
+
+    api_key: str - your Brandfetch API key
+
+    -- Brand Search API
+
+    client_id: str - your Brandfetch Client ID
+
+    async_tools: bool = True - if True, will use async tools, if False, will use sync tools
+    brand: bool = False - if True, will use brand api, if False, will not use brand api
+    search: bool = False - if True, will use brand search api, if False, will not use brand search api
+    """
+
+    def __init__(
+        self,
+        api_key: Optional[str] = None,
+        client_id: Optional[str] = None,
+        base_url: str = "https://api.brandfetch.io/v2",
+        timeout: Optional[float] = 20.0,
+        async_tools: bool = False,
+        brand: bool = True,
+        search: bool = False,
+        **kwargs,
+    ):
+        self.api_key = api_key or getenv("BRANDFETCH_API_KEY")
+        self.client_id = client_id or getenv("BRANDFETCH_CLIENT_ID")
+        self.base_url = base_url
+        self.timeout = httpx.Timeout(timeout)
+        self.async_tools = async_tools
+        self.search_url = f"{self.base_url}/search"
+        self.brand_url = f"{self.base_url}/brands"
+
+        tools: list[Any] = []
+        if self.async_tools:
+            if brand:
+                tools.append(self.asearch_by_identifier)
+            if search:
+                tools.append(self.asearch_by_brand)
+        else:
+            if brand:
+                tools.append(self.search_by_identifier)
+            if search:
+                tools.append(self.search_by_brand)
+        name = kwargs.pop("name", "brandfetch_tools")
+        super().__init__(name=name, tools=tools, **kwargs)
+
+    async def asearch_by_identifier(self, identifier: str) -> dict[str, Any]:
+        """
+        Search for brand data by identifier (domain, brand id, isin, stock ticker).
+
+        Args:
+            identifier: Options are you can use: Domain (nike.com), Brand ID (id_0dwKPKT), ISIN (US6541061031), Stock Ticker (NKE)
+        Returns:
+            Dict containing brand data including logos, colors, fonts, and other brand assets
+
+        Raises:
+            ValueError: If no API key is provided
+        """
+        if not self.api_key:
+            raise ValueError("API key is required for brand search by identifier")
+
+        url = f"{self.brand_url}/{identifier}"
+        headers = {"Authorization": f"Bearer {self.api_key}"}
+
+        try:
+            async with httpx.AsyncClient(timeout=self.timeout) as client:
+                response = await client.get(url, headers=headers)
+                response.raise_for_status()
+                return response.json()
+        except httpx.HTTPStatusError as e:
+            if e.response.status_code == 404:
+                return {"error": f"Brand not found for identifier: {identifier}"}
+            elif e.response.status_code == 401:
+                return {"error": "Invalid API key"}
+            elif e.response.status_code == 429:
+                return {"error": "Rate limit exceeded"}
+            else:
+                return {"error": f"API error: {e.response.status_code}"}
+        except httpx.RequestError as e:
+            return {"error": f"Request failed: {str(e)}"}
+
+    def search_by_identifier(self, identifier: str) -> dict[str, Any]:
+        """
+        Search for brand data by identifier (domain, brand id, isin, stock ticker).
+
+        Args:
+            identifier: Options are you can use: Domain (nike.com), Brand ID (id_0dwKPKT), ISIN (US6541061031), Stock Ticker (NKE)
+
+        Returns:
+            Dict containing brand data including logos, colors, fonts, and other brand assets
+
+        Raises:
+            ValueError: If no API key is provided
+        """
+        if not self.api_key:
+            raise ValueError("API key is required for brand search by identifier")
+
+        url = f"{self.brand_url}/{identifier}"
+        headers = {"Authorization": f"Bearer {self.api_key}"}
+
+        try:
+            with httpx.Client(timeout=self.timeout) as client:
+                response = client.get(url, headers=headers)
+                response.raise_for_status()
+                return response.json()
+        except httpx.HTTPStatusError as e:
+            if e.response.status_code == 404:
+                return {"error": f"Brand not found for identifier: {identifier}"}
+            elif e.response.status_code == 401:
+                return {"error": "Invalid API key"}
+            elif e.response.status_code == 429:
+                return {"error": "Rate limit exceeded"}
+            else:
+                return {"error": f"API error: {e.response.status_code}"}
+        except httpx.RequestError as e:
+            return {"error": f"Request failed: {str(e)}"}
+
+    async def asearch_by_brand(self, name: str) -> dict[str, Any]:
+        """
+        Search for brands by name using the Brand Search API - can give you the right brand id to use for the brand api.
+
+        Args:
+            name: Brand name to search for (e.g., 'Google', 'Apple')
+
+        Returns:
+            Dict containing search results with brand matches
+
+        Raises:
+            ValueError: If no client ID is provided
+        """
+        if not self.client_id:
+            raise ValueError("Client ID is required for brand search by name")
+
+        url = f"{self.search_url}/{name}"
+        params = {"c": self.client_id}
+
+        try:
+            async with httpx.AsyncClient(timeout=self.timeout) as client:
+                response = await client.get(url, params=params)
+                response.raise_for_status()
+                return response.json()
+        except httpx.HTTPStatusError as e:
+            if e.response.status_code == 404:
+                return {"error": f"No brands found for name: {name}"}
+            elif e.response.status_code == 401:
+                return {"error": "Invalid client ID"}
+            elif e.response.status_code == 429:
+                return {"error": "Rate limit exceeded"}
+            else:
+                return {"error": f"API error: {e.response.status_code}"}
+        except httpx.RequestError as e:
+            return {"error": f"Request failed: {str(e)}"}
+
+    def search_by_brand(self, name: str) -> dict[str, Any]:
+        """
+        Search for brands by name using the Brand Search API - can give you the right brand id to use for the brand api.
+
+        Args:
+            name: Brand name to search for (e.g., 'Google', 'Apple')
+
+        Returns:
+            Dict containing search results with brand matches
+
+        Raises:
+            ValueError: If no client ID is provided
+        """
+        if not self.client_id:
+            raise ValueError("Client ID is required for brand search by name")
+
+        url = f"{self.search_url}/{name}"
+        params = {"c": self.client_id}
+
+        try:
+            with httpx.Client(timeout=self.timeout) as client:
+                response = client.get(url, params=params)
+                response.raise_for_status()
+                return response.json()
+        except httpx.HTTPStatusError as e:
+            if e.response.status_code == 404:
+                return {"error": f"No brands found for name: {name}"}
+            elif e.response.status_code == 401:
+                return {"error": "Invalid client ID"}
+            elif e.response.status_code == 429:
+                return {"error": "Rate limit exceeded"}
+            else:
+                return {"error": f"API error: {e.response.status_code}"}
+        except httpx.RequestError as e:
+            return {"error": f"Request failed: {str(e)}"}

agno/tools/github.py

@@ -472,7 +472,7 @@ class GithubTools(Toolkit):
         log_debug(f"Listing issues for repository: {repo_name} with state: {state}, page: {page}, per_page: {per_page}")
         try:
             repo = self.g.get_repo(repo_name)
-            
+
             issues = repo.get_issues(state=state)
 
             # Filter out pull requests after fetching issues
@@ -482,21 +482,21 @@ class GithubTools(Toolkit):
                 if not issue.pull_request:
                     all_issues.append(issue)
                     total_issues += 1
-            
+
             # Calculate pagination metadata
             total_pages = (total_issues + per_page - 1) // per_page
-            
+
             # Validate page number
             if page < 1:
                 page = 1
             elif page > total_pages and total_pages > 0:
                 page = total_pages
-            
+
             # Get the specified page of results
             issue_list = []
             page_start = (page - 1) * per_page
             page_end = page_start + per_page
-            
+
             for i in range(page_start, min(page_end, total_issues)):
                 if i < len(all_issues):
                     issue = all_issues[i]
@@ -509,19 +509,11 @@ class GithubTools(Toolkit):
                         "url": issue.html_url,
                     }
                     issue_list.append(issue_info)
-            
-            meta = {
-                "current_page": page,
-                "per_page": per_page,
-                "total_items": total_issues,
-                "total_pages": total_pages
-            }
-            
-            response = {
-                "data": issue_list,
-                "meta": meta
-            }
-            
+
+            meta = {"current_page": page, "per_page": per_page, "total_items": total_issues, "total_pages": total_pages}
+
+            response = {"data": issue_list, "meta": meta}
+
             return json.dumps(response, indent=2)
         except GithubException as e:
             logger.error(f"Error listing issues: {e}")