agno 1.7.9__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

@@ -310,6 +310,7 @@ class Team:
         model: Optional[Model] = None,
         name: Optional[str] = None,
         team_id: Optional[str] = None,
+        role: Optional[str] = None,
         user_id: Optional[str] = None,
         session_id: Optional[str] = None,
         session_name: Optional[str] = None,
@@ -390,6 +391,7 @@ class Team:
 
         self.name = name
         self.team_id = team_id
+        self.role = role
 
         self.user_id = user_id
         self.session_id = session_id
@@ -1351,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,
@@ -5337,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"
@@ -5348,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 += (
@@ -5453,6 +5463,10 @@ class Team:
         if self.description is not None:
             system_message_content += f"<description>\n{self.description}\n</description>\n\n"
 
+        # 3.3.4 Then add the Team role if provided
+        if self.role is not None:
+            system_message_content += f"\n<your_role>\n{self.role}\n</your_role>\n\n"
+
         # 3.3.5 Then add instructions for the Agent
         if len(instructions) > 0:
             system_message_content += "<instructions>"
@@ -5645,7 +5659,7 @@ class Team:
                 if isinstance(message, str):
                     user_message_content = message
                 else:
-                    user_message_content = "\n".join(message)
+                    user_message_content = "\n".join(str(message))
 
             # Add references to user message
             if (
@@ -7152,9 +7166,10 @@ class Team:
                     # If the team_session_state is already set, merge the team_session_state from the database with the current team_session_state
                     if self.team_session_state is not None and len(self.team_session_state) > 0:
                         # This updates team_session_state_from_db
-                        merge_dictionaries(team_session_state_from_db, self.team_session_state)
-                    # Update the current team_session_state
-                    self.team_session_state = team_session_state_from_db
+                        merge_dictionaries(self.team_session_state, team_session_state_from_db)
+                    else:
+                        # Update the current team_session_state
+                        self.team_session_state = team_session_state_from_db
 
             if "workflow_session_state" in session.session_data:
                 workflow_session_state_from_db = session.session_data.get("workflow_session_state")
@@ -7166,9 +7181,10 @@ class Team:
                     # If the workflow_session_state is already set, merge the workflow_session_state from the database with the current workflow_session_state
                     if self.workflow_session_state is not None and len(self.workflow_session_state) > 0:
                         # This updates workflow_session_state_from_db
-                        merge_dictionaries(workflow_session_state_from_db, self.workflow_session_state)
-                    # Update the current workflow_session_state
-                    self.workflow_session_state = workflow_session_state_from_db
+                        merge_dictionaries(self.workflow_session_state, workflow_session_state_from_db)
+                    else:
+                        # Update the current workflow_session_state
+                        self.workflow_session_state = workflow_session_state_from_db
 
             # Get the session_metrics from the database
             if "session_metrics" in session.session_data:

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

@@ -458,35 +458,63 @@ class GithubTools(Toolkit):
             logger.error(f"Error creating issue: {e}")
             return json.dumps({"error": str(e)})
 
-    def list_issues(self, repo_name: str, state: str = "open", limit: int = 20) -> str:
-        """List issues for a repository.
+    def list_issues(self, repo_name: str, state: str = "open", page: int = 1, per_page: int = 20) -> str:
+        """List issues for a repository with pagination.
 
         Args:
             repo_name (str): The full name of the repository (e.g., 'owner/repo').
             state (str, optional): The state of issues to list ('open', 'closed', 'all'). Defaults to 'open'.
-            limit (int, optional): The maximum number of issues to return. Defaults to 20.
+            page (int, optional): Page number of results to return, counting from 1. Defaults to 1.
+            per_page (int, optional): Number of results per page. Defaults to 20.
         Returns:
-            A JSON-formatted string containing a list of issues.
+            A JSON-formatted string containing a list of issues with pagination metadata.
         """
-        log_debug(f"Listing issues for repository: {repo_name} with state: {state}")
+        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
-            logger.info(f"Issues: {issues}")
-            filtered_issues = [issue for issue in issues if not issue.pull_request]
+            total_issues = 0
+            all_issues = []
+            for issue in issues:
+                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 = []
-            for issue in filtered_issues[:limit]:
-                issue_info = {
-                    "number": issue.number,
-                    "title": issue.title,
-                    "user": issue.user.login,
-                    "created_at": issue.created_at.isoformat(),
-                    "state": issue.state,
-                    "url": issue.html_url,
-                }
-                issue_list.append(issue_info)
-            return json.dumps(issue_list, indent=2)
+            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]
+                    issue_info = {
+                        "number": issue.number,
+                        "title": issue.title,
+                        "user": issue.user.login,
+                        "created_at": issue.created_at.isoformat(),
+                        "state": issue.state,
+                        "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}
+
+            return json.dumps(response, indent=2)
         except GithubException as e:
             logger.error(f"Error listing issues: {e}")
             return json.dumps({"error": str(e)})