agno 2.0.0rc2__py3-none-any.whl → 2.3.0__py3-none-any.whl

agno/utils/serialize.py

@@ -0,0 +1,32 @@
+"""JSON serialization utilities for handling datetime and enum objects."""
+
+from datetime import date, datetime, time
+from enum import Enum
+from typing import Any
+
+
+def json_serializer(obj: Any) -> Any:
+    """Custom JSON serializer for objects not serializable by default json module.
+
+    Handles:
+    - datetime, date, time objects -> ISO format strings
+    - Enum objects -> their values (or names if values are not JSON-serializable)
+    - All other objects -> string representation
+
+    Args:
+        obj: Object to serialize
+
+    Returns:
+        JSON-serializable representation of the object
+    """
+    # Datetime like
+    if isinstance(obj, (datetime, date, time)):
+        return obj.isoformat()
+
+    # Enums
+    if isinstance(obj, Enum):
+        v = obj.value
+        return v if isinstance(v, (str, int, float, bool, type(None))) else obj.name
+
+    # Fallback to string
+    return str(obj)

agno/utils/streamlit.py

@@ -1,14 +1,20 @@
 from datetime import datetime
 from typing import Any, Callable, Dict, List, Optional
 
-import streamlit as st
-
-from agno.agent import Agent
-from agno.db.base import SessionType
-from agno.models.anthropic import Claude
-from agno.models.google import Gemini
-from agno.models.openai import OpenAIChat
-from agno.utils.log import logger
+try:
+    from agno.agent import Agent
+    from agno.db.base import SessionType
+    from agno.models.anthropic import Claude
+    from agno.models.google import Gemini
+    from agno.models.openai import OpenAIChat
+    from agno.utils.log import logger
+except ImportError:
+    raise ImportError("`agno` not installed. Please install using `pip install agno`")
+
+try:
+    import streamlit as st
+except ImportError:
+    raise ImportError("`streamlit` not installed. Please install using `pip install streamlit`")
 
 
 def add_message(role: str, content: str, tool_calls: Optional[List[Dict[str, Any]]] = None) -> None:
@@ -74,7 +80,7 @@ def session_selector_widget(agent: Agent, model_id: str, agent_creation_callback
     session_options = []
     session_dict = {}
 
-    for session in sessions:
+    for session in sessions:  # type: ignore
         if not hasattr(session, "session_id") or not session.session_id:
             continue
 
@@ -446,7 +452,7 @@ MODELS = [
     "gpt-4o",
     "o3-mini",
     "gpt-5",
-    "claude-4-sonnet",
+    "claude-sonnet-4-5-20250929",
     "gemini-2.5-pro",
 ]
 

agno/utils/string.py

@@ -1,7 +1,9 @@
 import hashlib
 import json
 import re
+import uuid
 from typing import Optional, Type
+from uuid import uuid4
 
 from pydantic import BaseModel, ValidationError
 
@@ -156,6 +158,15 @@ def _parse_individual_json(content: str, output_schema: Type[BaseModel]) -> Opti
 def parse_response_model_str(content: str, output_schema: Type[BaseModel]) -> Optional[BaseModel]:
     structured_output = None
 
+    # Extract thinking content first to prevent <think> tags from corrupting JSON
+    from agno.utils.reasoning import extract_thinking_content
+
+    # handle thinking content b/w <think> tags
+    if "</think>" in content:
+        reasoning_content, output_content = extract_thinking_content(content)
+        if reasoning_content:
+            content = output_content
+
     # Clean content first to simplify all parsing attempts
     cleaned_content = _clean_json_content(content)
 
@@ -188,3 +199,33 @@ def parse_response_model_str(content: str, output_schema: Type[BaseModel]) -> Op
                     logger.warning("All parsing attempts failed.")
 
     return structured_output
+
+
+def generate_id(seed: Optional[str] = None) -> str:
+    """
+    Generate a deterministic UUID5 based on a seed string.
+    If no seed is provided, generate a random UUID4.
+
+    Args:
+        seed (str): The seed string to generate the UUID from.
+
+    Returns:
+        str: A deterministic UUID5 string.
+    """
+    if seed is None:
+        return str(uuid4())
+    return str(uuid.uuid5(uuid.NAMESPACE_DNS, seed))
+
+
+def generate_id_from_name(name: Optional[str] = None) -> str:
+    """
+    Generate a deterministic ID from a name string.
+    If no name is provided, generate a random UUID4.
+
+    Args:
+        name (str): The name string to generate the ID from.
+    """
+    if name:
+        return name.lower().replace(" ", "-").replace("_", "-")
+    else:
+        return str(uuid4())

agno/utils/team.py

@@ -1,6 +1,10 @@
-from typing import TYPE_CHECKING, Optional, Union
+from typing import TYPE_CHECKING, Any, Dict, List, Optional, Union
 
 from agno.agent import Agent
+from agno.media import Audio, File, Image, Video
+from agno.run.agent import RunOutput
+from agno.run.team import TeamRunOutput
+from agno.utils.log import log_debug
 from agno.utils.string import is_valid_uuid, url_safe_string
 
 if TYPE_CHECKING:
@@ -9,19 +13,20 @@ if TYPE_CHECKING:
 
 def format_member_agent_task(
     task_description: str,
-    expected_output: Optional[str] = None,
     team_member_interactions_str: Optional[str] = None,
+    team_history_str: Optional[str] = None,
 ) -> str:
-    member_agent_task = "You are a member of a team of agents. Your goal is to complete the following task:"
-    member_agent_task += f"\n\n<task>\n{task_description}\n</task>"
-
-    if expected_output is not None:
-        member_agent_task += f"\n\n<expected_output>\n{expected_output}\n</expected_output>"
+    member_task_str = ""
 
     if team_member_interactions_str:
-        member_agent_task += f"\n\n{team_member_interactions_str}"
+        member_task_str += f"{team_member_interactions_str}\n\n"
+
+    if team_history_str:
+        member_task_str += f"{team_history_str}\n\n"
 
-    return member_agent_task
+    member_task_str += f"{task_description}"
+
+    return member_task_str
 
 
 def get_member_id(member: Union[Agent, "Team"]) -> str:
@@ -48,3 +53,87 @@ def get_member_id(member: Union[Agent, "Team"]) -> str:
     else:
         url_safe_member_id = None
     return url_safe_member_id
+
+
+def add_interaction_to_team_run_context(
+    team_run_context: Dict[str, Any],
+    member_name: str,
+    task: str,
+    run_response: Union[RunOutput, TeamRunOutput],
+) -> None:
+    if "member_responses" not in team_run_context:
+        team_run_context["member_responses"] = []
+    team_run_context["member_responses"].append(
+        {
+            "member_name": member_name,
+            "task": task,
+            "run_response": run_response,
+        }
+    )
+    log_debug(f"Updated team run context with member name: {member_name}")
+
+
+def get_team_member_interactions_str(team_run_context: Dict[str, Any]) -> str:
+    if not team_run_context:
+        return ""
+    team_member_interactions_str = ""
+    if "member_responses" in team_run_context:
+        team_member_interactions_str += "<member_interaction_context>\nSee below interactions wit other team members.\n"
+
+        for interaction in team_run_context["member_responses"]:
+            response_dict = interaction["run_response"].to_dict()
+            response_content = (
+                response_dict.get("content")
+                or ",".join([tool.get("content", "") for tool in response_dict.get("tools", [])])
+                or ""
+            )
+            team_member_interactions_str += f"Member: {interaction['member_name']}\n"
+            team_member_interactions_str += f"Task: {interaction['task']}\n"
+            team_member_interactions_str += f"Response: {response_content}\n"
+            team_member_interactions_str += "\n"
+        team_member_interactions_str += "</member_interaction_context>\n"
+    return team_member_interactions_str
+
+
+def get_team_run_context_images(team_run_context: Dict[str, Any]) -> List[Image]:
+    if not team_run_context:
+        return []
+    images = []
+    if "member_responses" in team_run_context:
+        for interaction in team_run_context["member_responses"]:
+            if interaction["run_response"].images:
+                images.extend(interaction["run_response"].images)
+    return images
+
+
+def get_team_run_context_videos(team_run_context: Dict[str, Any]) -> List[Video]:
+    if not team_run_context:
+        return []
+    videos = []
+    if "member_responses" in team_run_context:
+        for interaction in team_run_context["member_responses"]:
+            if interaction["run_response"].videos:
+                videos.extend(interaction["run_response"].videos)
+    return videos
+
+
+def get_team_run_context_audio(team_run_context: Dict[str, Any]) -> List[Audio]:
+    if not team_run_context:
+        return []
+    audio = []
+    if "member_responses" in team_run_context:
+        for interaction in team_run_context["member_responses"]:
+            if interaction["run_response"].audio:
+                audio.extend(interaction["run_response"].audio)
+    return audio
+
+
+def get_team_run_context_files(team_run_context: Dict[str, Any]) -> List[File]:
+    if not team_run_context:
+        return []
+    files = []
+    if "member_responses" in team_run_context:
+        for interaction in team_run_context["member_responses"]:
+            if interaction["run_response"].files:
+                files.extend(interaction["run_response"].files)
+    return files

agno/utils/tools.py

@@ -13,7 +13,7 @@ def get_function_call_for_tool_call(
         _tool_call_function = tool_call.get("function")
         if _tool_call_function is not None:
             _tool_call_function_name = _tool_call_function.get("name")
-            _tool_call_function_arguments_str = _tool_call_function.get("arguments")
+            _tool_call_function_arguments_str = _tool_call_function.get("arguments") or "{}"
             if _tool_call_function_name is not None:
                 return get_function_call(
                     name=_tool_call_function_name,

agno/vectordb/base.py

@@ -2,11 +2,28 @@ from abc import ABC, abstractmethod
 from typing import Any, Dict, List, Optional
 
 from agno.knowledge.document import Document
+from agno.utils.string import generate_id
 
 
 class VectorDb(ABC):
     """Base class for Vector Databases"""
 
+    def __init__(self, *, id: Optional[str] = None, name: Optional[str] = None, description: Optional[str] = None):
+        """Initialize base VectorDb.
+
+        Args:
+            id: Optional custom ID. If not provided, an id will be generated.
+            name: Optional name for the vector database.
+            description: Optional description for the vector database.
+        """
+        if name is None:
+            name = self.__class__.__name__
+
+        self.name = name
+        self.description = description
+        # Last resort fallback to generate id from name if ID not specified
+        self.id = id if id else generate_id(name)
+
     @abstractmethod
     def create(self) -> None:
         raise NotImplementedError
@@ -55,13 +72,11 @@ class VectorDb(ABC):
         raise NotImplementedError
 
     @abstractmethod
-    def search(self, query: str, limit: int = 5, filters: Optional[Dict[str, Any]] = None) -> List[Document]:
+    def search(self, query: str, limit: int = 5, filters: Optional[Any] = None) -> List[Document]:
         raise NotImplementedError
 
     @abstractmethod
-    async def async_search(
-        self, query: str, limit: int = 5, filters: Optional[Dict[str, Any]] = None
-    ) -> List[Document]:
+    async def async_search(self, query: str, limit: int = 5, filters: Optional[Any] = None) -> List[Document]:
         raise NotImplementedError
 
     @abstractmethod
@@ -106,3 +121,7 @@ class VectorDb(ABC):
     @abstractmethod
     def delete_by_content_id(self, content_id: str) -> bool:
         raise NotImplementedError
+
+    @abstractmethod
+    def get_supported_search_types(self) -> List[str]:
+        raise NotImplementedError

agno/vectordb/cassandra/cassandra.py

@@ -1,9 +1,10 @@
 import asyncio
-from typing import Any, Dict, Iterable, List, Optional
+from typing import Any, Dict, Iterable, List, Optional, Union
 
+from agno.filters import FilterExpr
 from agno.knowledge.document import Document
 from agno.knowledge.embedder import Embedder
-from agno.utils.log import log_debug, log_error, log_info
+from agno.utils.log import log_debug, log_error, log_info, log_warning
 from agno.vectordb.base import VectorDb
 from agno.vectordb.cassandra.index import AgnoMetadataVectorCassandraTable
 
@@ -15,6 +16,8 @@ class Cassandra(VectorDb):
         keyspace: str,
         embedder: Optional[Embedder] = None,
         session=None,
+        name: Optional[str] = None,
+        description: Optional[str] = None,
     ) -> None:
         if not table_name:
             raise ValueError("Table name must be provided.")
@@ -30,6 +33,9 @@ class Cassandra(VectorDb):
 
             embedder = OpenAIEmbedder()
             log_info("Embedder not provided, using OpenAIEmbedder as default.")
+        # Initialize base class with name and description
+        super().__init__(name=name, description=description)
+
         self.table_name: str = table_name
         self.embedder: Embedder = embedder
         self.session = session
@@ -119,12 +125,52 @@ class Cassandra(VectorDb):
         """Insert documents asynchronously by running in a thread."""
         log_info(f"Cassandra VectorDB : Inserting Documents to the table {self.table_name}")
 
-        for doc in documents:
+        if self.embedder.enable_batch and hasattr(self.embedder, "async_get_embeddings_batch_and_usage"):
+            # Use batch embedding when enabled and supported
             try:
-                embed_tasks = [doc.async_embed(embedder=self.embedder)]
-                await asyncio.gather(*embed_tasks, return_exceptions=True)
+                # Extract content from all documents
+                doc_contents = [doc.content for doc in documents]
+
+                # Get batch embeddings and usage
+                embeddings, usages = await self.embedder.async_get_embeddings_batch_and_usage(doc_contents)
+
+                # Process documents with pre-computed embeddings
+                for j, doc in enumerate(documents):
+                    try:
+                        if j < len(embeddings):
+                            doc.embedding = embeddings[j]
+                            doc.usage = usages[j] if j < len(usages) else None
+                    except Exception as e:
+                        log_error(f"Error assigning batch embedding to document '{doc.name}': {e}")
+
             except Exception as e:
-                log_error(f"Error processing document '{doc.name}': {e}")
+                # Check if this is a rate limit error - don't fall back as it would make things worse
+                error_str = str(e).lower()
+                is_rate_limit = any(
+                    phrase in error_str
+                    for phrase in ["rate limit", "too many requests", "429", "trial key", "api calls / minute"]
+                )
+
+                if is_rate_limit:
+                    log_error(f"Rate limit detected during batch embedding. {e}")
+                    raise e
+                else:
+                    log_error(f"Async batch embedding failed, falling back to individual embeddings: {e}")
+                    # Fall back to individual embedding
+                    for doc in documents:
+                        try:
+                            embed_tasks = [doc.async_embed(embedder=self.embedder)]
+                            await asyncio.gather(*embed_tasks, return_exceptions=True)
+                        except Exception as e:
+                            log_error(f"Error processing document '{doc.name}': {e}")
+        else:
+            # Use individual embedding (original behavior)
+            for doc in documents:
+                try:
+                    embed_tasks = [doc.async_embed(embedder=self.embedder)]
+                    await asyncio.gather(*embed_tasks, return_exceptions=True)
+                except Exception as e:
+                    log_error(f"Error processing document '{doc.name}': {e}")
 
         futures = []
         for doc in documents:
@@ -159,13 +205,17 @@ class Cassandra(VectorDb):
             self.delete_by_content_hash(content_hash)
         await self.async_insert(content_hash, documents, filters)
 
-    def search(self, query: str, limit: int = 5, filters: Optional[Dict[str, Any]] = None) -> List[Document]:
+    def search(
+        self, query: str, limit: int = 5, filters: Optional[Union[Dict[str, Any], List[FilterExpr]]] = None
+    ) -> List[Document]:
         """Keyword-based search on document metadata."""
         log_debug(f"Cassandra VectorDB : Performing Vector Search on {self.table_name} with query {query}")
+        if filters is not None:
+            log_warning("Filters are not yet supported in Cassandra. No filters will be applied.")
         return self.vector_search(query=query, limit=limit)
 
     async def async_search(
-        self, query: str, limit: int = 5, filters: Optional[Dict[str, Any]] = None
+        self, query: str, limit: int = 5, filters: Optional[Union[Dict[str, Any], List[FilterExpr]]] = None
     ) -> List[Document]:
         """Search asynchronously by running in a thread."""
         return await asyncio.to_thread(self.search, query, limit, filters)
@@ -176,7 +226,9 @@ class Cassandra(VectorDb):
     ) -> List[Document]:
         return [self._row_to_document(row=hit) for hit in hits]
 
-    def vector_search(self, query: str, limit: int = 5) -> List[Document]:
+    def vector_search(
+        self, query: str, limit: int = 5, filters: Optional[Union[Dict[str, Any], List[FilterExpr]]] = None
+    ) -> List[Document]:
         """Vector similarity search implementation."""
         query_embedding = self.embedder.get_embedding(query)
         hits = list(
@@ -443,3 +495,7 @@ class Cassandra(VectorDb):
         except Exception as e:
             log_error(f"Error updating metadata for content_id {content_id}: {e}")
             raise
+
+    def get_supported_search_types(self) -> List[str]:
+        """Get the supported search types for this vector database."""
+        return []  # Cassandra doesn't use SearchType enum