agno 2.0.6__py3-none-any.whl → 2.0.8__py3-none-any.whl

agno/utils/gemini.py

@@ -1,5 +1,7 @@
 from pathlib import Path
-from typing import Any, Dict, List, Optional
+from typing import Any, Dict, List, Optional, Type, Union
+
+from pydantic import BaseModel
 
 from agno.media import Image
 from agno.utils.log import log_error, log_warning
@@ -9,12 +11,119 @@ try:
         FunctionDeclaration,
         Schema,
         Tool,
-        Type,
+    )
+    from google.genai.types import (
+        Type as GeminiType,
     )
 except ImportError:
     raise ImportError("`google-genai` not installed. Please install it using `pip install google-genai`")
 
 
+def prepare_response_schema(pydantic_model: Type[BaseModel]) -> Union[Type[BaseModel], Schema]:
+    """
+    Prepare a Pydantic model for use as Gemini response schema.
+
+    Returns the model directly if Gemini can handle it natively,
+    otherwise converts to Gemini's Schema format.
+
+    Args:
+        pydantic_model: A Pydantic model class
+
+    Returns:
+        Either the original Pydantic model or a converted Schema object
+    """
+    schema_dict = pydantic_model.model_json_schema()
+
+    # Convert to Gemini Schema if the model has problematic patterns
+    if needs_conversion(schema_dict):
+        try:
+            converted = convert_schema(schema_dict)
+        except Exception as e:
+            log_warning(f"Failed to convert schema for {pydantic_model}: {e}")
+            converted = None
+
+        if converted is None:
+            # If conversion fails, let Gemini handle it directly
+            return pydantic_model
+        return converted
+
+    # Gemini can handle this model directly
+    return pydantic_model
+
+
+def needs_conversion(schema_dict: Dict[str, Any]) -> bool:
+    """
+    Check if a schema needs conversion for Gemini.
+
+    Returns True if the schema has:
+    - Self-references or circular references
+    - Dict fields (additionalProperties) that Gemini doesn't handle well
+    - Empty object definitions that Gemini rejects
+    """
+    # Check for dict fields (additionalProperties) anywhere in the schema
+    if has_additional_properties(schema_dict):
+        return True
+
+    # Check if schema has $defs with circular references
+    if "$defs" in schema_dict:
+        defs = schema_dict["$defs"]
+        for def_name, def_schema in defs.items():
+            ref_path = f"#/$defs/{def_name}"
+            if has_self_reference(def_schema, ref_path):
+                return True
+
+    return False
+
+
+def has_additional_properties(schema: Any) -> bool:
+    """Check if schema has additionalProperties (Dict fields)"""
+    if isinstance(schema, dict):
+        # Direct check
+        if "additionalProperties" in schema:
+            return True
+
+        # Check properties recursively
+        if "properties" in schema:
+            for prop_schema in schema["properties"].values():
+                if has_additional_properties(prop_schema):
+                    return True
+
+        # Check array items
+        if "items" in schema:
+            if has_additional_properties(schema["items"]):
+                return True
+
+    return False
+
+
+def has_self_reference(schema: Dict, target_ref: str) -> bool:
+    """Check if a schema references itself (directly or indirectly)"""
+    if isinstance(schema, dict):
+        # Direct self-reference
+        if schema.get("$ref") == target_ref:
+            return True
+
+        # Check properties
+        if "properties" in schema:
+            for prop_schema in schema["properties"].values():
+                if has_self_reference(prop_schema, target_ref):
+                    return True
+
+        # Check array items
+        if "items" in schema:
+            if has_self_reference(schema["items"], target_ref):
+                return True
+
+        # Check anyOf/oneOf/allOf
+        for key in ["anyOf", "oneOf", "allOf"]:
+            if key in schema:
+                for sub_schema in schema[key]:
+                    if has_self_reference(sub_schema, target_ref):
+                        return True
+
+    return False
+
+
 def format_image_for_message(image: Image) -> Optional[Dict[str, Any]]:
     # Case 1: Image is a URL
     # Download the image from the URL and add it as base64 encoded data
@@ -66,7 +175,9 @@ def format_image_for_message(image: Image) -> Optional[Dict[str, Any]]:
         return None
 
 
-def convert_schema(schema_dict: Dict[str, Any], root_schema: Optional[Dict[str, Any]] = None) -> Optional[Schema]:
+def convert_schema(
+    schema_dict: Dict[str, Any], root_schema: Optional[Dict[str, Any]] = None, visited_refs: Optional[set] = None
+) -> Optional[Schema]:
     """
     Recursively convert a JSON-like schema dictionary to a types.Schema object.
 
@@ -74,23 +185,39 @@ def convert_schema(schema_dict: Dict[str, Any], root_schema: Optional[Dict[str,
         schema_dict (dict): The JSON schema dictionary with keys like "type", "description",
                             "properties", and "required".
         root_schema (dict, optional): The root schema containing $defs for resolving $ref
+        visited_refs (set, optional): Set of visited $ref paths to detect circular references
 
     Returns:
         types.Schema: The converted schema.
     """
 
-    # If this is the initial call, set root_schema to self
+    # If this is the initial call, set root_schema to self and initialize visited_refs
     if root_schema is None:
         root_schema = schema_dict
+    if visited_refs is None:
+        visited_refs = set()
 
-    # Handle $ref references
+    # Handle $ref references with cycle detection
     if "$ref" in schema_dict:
         ref_path = schema_dict["$ref"]
+
+        # Check for circular reference
+        if ref_path in visited_refs:
+            # Return a basic object schema to break the cycle
+            return Schema(
+                type=GeminiType.OBJECT,
+                description=f"Circular reference to {ref_path}",
+            )
+
         if ref_path.startswith("#/$defs/"):
             def_name = ref_path.split("/")[-1]
             if "$defs" in root_schema and def_name in root_schema["$defs"]:
+                # Add to visited set before recursing
+                new_visited = visited_refs.copy()
+                new_visited.add(ref_path)
+
                 referenced_schema = root_schema["$defs"][def_name]
-                return convert_schema(referenced_schema, root_schema)
+                return convert_schema(referenced_schema, root_schema, new_visited)
         # If we can't resolve the reference, return None
         return None
 
@@ -103,7 +230,7 @@ def convert_schema(schema_dict: Dict[str, Any], root_schema: Optional[Dict[str,
     # Handle enum types
     if "enum" in schema_dict:
         enum_values = schema_dict["enum"]
-        return Schema(type=Type.STRING, enum=enum_values, description=description, default=default)
+        return Schema(type=GeminiType.STRING, enum=enum_values, description=description, default=default)
 
     if schema_type == "object":
         # Handle regular objects with properties
@@ -117,8 +244,8 @@ def convert_schema(schema_dict: Dict[str, Any], root_schema: Optional[Dict[str,
                     prop_def["type"] = prop_type[0]
                     is_nullable = True
 
-                # Process property schema (pass root_schema for $ref resolution)
-                converted_schema = convert_schema(prop_def, root_schema)
+                # Process property schema (pass root_schema and visited_refs for $ref resolution)
+                converted_schema = convert_schema(prop_def, root_schema, visited_refs)
                 if converted_schema is not None:
                     if is_nullable:
                         converted_schema.nullable = True
@@ -128,14 +255,14 @@ def convert_schema(schema_dict: Dict[str, Any], root_schema: Optional[Dict[str,
 
             if properties:
                 return Schema(
-                    type=Type.OBJECT,
+                    type=GeminiType.OBJECT,
                     properties=properties,
                     required=required,
                     description=description,
                     default=default,
                 )
             else:
-                return Schema(type=Type.OBJECT, description=description, default=default)
+                return Schema(type=GeminiType.OBJECT, description=description, default=default)
 
         # Handle Dict types (objects with additionalProperties but no properties)
         elif "additionalProperties" in schema_dict:
@@ -170,7 +297,7 @@ def convert_schema(schema_dict: Dict[str, Any], root_schema: Optional[Dict[str,
                     placeholder_properties["example_key"].items = {}  # type: ignore
 
                 return Schema(
-                    type=Type.OBJECT,
+                    type=GeminiType.OBJECT,
                     properties=placeholder_properties,
                     description=description
                     or f"Dictionary with {value_type.lower()} values{type_description_suffix}. Can contain any number of key-value pairs.",
@@ -178,21 +305,22 @@ def convert_schema(schema_dict: Dict[str, Any], root_schema: Optional[Dict[str,
                 )
             else:
                 # additionalProperties is false or true
-                return Schema(type=Type.OBJECT, description=description, default=default)
+                return Schema(type=GeminiType.OBJECT, description=description, default=default)
 
         # Handle empty objects
         else:
-            return Schema(type=Type.OBJECT, description=description, default=default)
+            return Schema(type=GeminiType.OBJECT, description=description, default=default)
 
     elif schema_type == "array" and "items" in schema_dict:
         if not schema_dict["items"]:  # Handle empty {}
-            items = Schema(type=Type.STRING)
+            items = Schema(type=GeminiType.STRING)
         else:
-            items = convert_schema(schema_dict["items"], root_schema)
+            converted_items = convert_schema(schema_dict["items"], root_schema, visited_refs)
+            items = converted_items if converted_items is not None else Schema(type=GeminiType.STRING)
         min_items = schema_dict.get("minItems")
         max_items = schema_dict.get("maxItems")
         return Schema(
-            type=Type.ARRAY,
+            type=GeminiType.ARRAY,
             description=description,
             items=items,
             min_items=min_items,
@@ -201,7 +329,7 @@ def convert_schema(schema_dict: Dict[str, Any], root_schema: Optional[Dict[str,
 
     elif schema_type == "string":
         schema_kwargs = {
-            "type": Type.STRING,
+            "type": GeminiType.STRING,
             "description": description,
             "default": default,
         }
@@ -224,7 +352,7 @@ def convert_schema(schema_dict: Dict[str, Any], root_schema: Optional[Dict[str,
     elif schema_type == "" and "anyOf" in schema_dict:
         any_of = []
         for sub_schema in schema_dict["anyOf"]:
-            sub_schema_converted = convert_schema(sub_schema, root_schema)
+            sub_schema_converted = convert_schema(sub_schema, root_schema, visited_refs)
             any_of.append(sub_schema_converted)
 
         is_nullable = False

agno/utils/models/claude.py

@@ -279,6 +279,15 @@ def format_messages(messages: List[Message]) -> Tuple[List[Dict[str, str]], str]
                             type="tool_use",
                         )
                     )
+        elif message.role == "tool":
+            content = []
+            content.append(
+                {
+                    "type": "tool_result",
+                    "tool_use_id": message.tool_call_id,
+                    "content": str(message.content),
+                }
+            )
 
         # Skip empty assistant responses
         if message.role == "assistant" and not content:

agno/utils/print_response/agent.py

@@ -44,6 +44,8 @@ def print_response_stream(
     console: Optional[Any] = None,
     add_history_to_context: Optional[bool] = None,
     dependencies: Optional[Dict[str, Any]] = None,
+    add_dependencies_to_context: Optional[bool] = None,
+    add_session_state_to_context: Optional[bool] = None,
     metadata: Optional[Dict[str, Any]] = None,
     **kwargs: Any,
 ):
@@ -90,6 +92,8 @@ def print_response_stream(
             knowledge_filters=knowledge_filters,
             debug_mode=debug_mode,
             add_history_to_context=add_history_to_context,
+            add_dependencies_to_context=add_dependencies_to_context,
+            add_session_state_to_context=add_session_state_to_context,
             dependencies=dependencies,
             metadata=metadata,
             **kwargs,
@@ -223,6 +227,8 @@ async def aprint_response_stream(
     console: Optional[Any] = None,
     add_history_to_context: Optional[bool] = None,
     dependencies: Optional[Dict[str, Any]] = None,
+    add_dependencies_to_context: Optional[bool] = None,
+    add_session_state_to_context: Optional[bool] = None,
     metadata: Optional[Dict[str, Any]] = None,
     **kwargs: Any,
 ):
@@ -269,6 +275,8 @@ async def aprint_response_stream(
             knowledge_filters=knowledge_filters,
             debug_mode=debug_mode,
             add_history_to_context=add_history_to_context,
+            add_dependencies_to_context=add_dependencies_to_context,
+            add_session_state_to_context=add_session_state_to_context,
             dependencies=dependencies,
             metadata=metadata,
             **kwargs,
@@ -490,6 +498,8 @@ def print_response(
     console: Optional[Any] = None,
     add_history_to_context: Optional[bool] = None,
     dependencies: Optional[Dict[str, Any]] = None,
+    add_dependencies_to_context: Optional[bool] = None,
+    add_session_state_to_context: Optional[bool] = None,
     metadata: Optional[Dict[str, Any]] = None,
     **kwargs: Any,
 ):
@@ -527,6 +537,8 @@ def print_response(
             knowledge_filters=knowledge_filters,
             debug_mode=debug_mode,
             add_history_to_context=add_history_to_context,
+            add_dependencies_to_context=add_dependencies_to_context,
+            add_session_state_to_context=add_session_state_to_context,
             dependencies=dependencies,
             metadata=metadata,
             **kwargs,
@@ -590,6 +602,8 @@ async def aprint_response(
     console: Optional[Any] = None,
     add_history_to_context: Optional[bool] = None,
     dependencies: Optional[Dict[str, Any]] = None,
+    add_dependencies_to_context: Optional[bool] = None,
+    add_session_state_to_context: Optional[bool] = None,
     metadata: Optional[Dict[str, Any]] = None,
     **kwargs: Any,
 ):
@@ -627,6 +641,8 @@ async def aprint_response(
             knowledge_filters=knowledge_filters,
             debug_mode=debug_mode,
             add_history_to_context=add_history_to_context,
+            add_dependencies_to_context=add_dependencies_to_context,
+            add_session_state_to_context=add_session_state_to_context,
             dependencies=dependencies,
             metadata=metadata,
             **kwargs,

agno/utils/print_response/team.py

@@ -36,6 +36,8 @@ def print_response(
     knowledge_filters: Optional[Dict[str, Any]] = None,
     add_history_to_context: Optional[bool] = None,
     dependencies: Optional[Dict[str, Any]] = None,
+    add_dependencies_to_context: Optional[bool] = None,
+    add_session_state_to_context: Optional[bool] = None,
     metadata: Optional[Dict[str, Any]] = None,
     debug_mode: Optional[bool] = None,
     **kwargs: Any,
@@ -88,6 +90,8 @@ def print_response(
             knowledge_filters=knowledge_filters,
             add_history_to_context=add_history_to_context,
             dependencies=dependencies,
+            add_dependencies_to_context=add_dependencies_to_context,
+            add_session_state_to_context=add_session_state_to_context,
             metadata=metadata,
             debug_mode=debug_mode,
             **kwargs,
@@ -317,6 +321,8 @@ def print_response_stream(
     knowledge_filters: Optional[Dict[str, Any]] = None,
     add_history_to_context: Optional[bool] = None,
     dependencies: Optional[Dict[str, Any]] = None,
+    add_dependencies_to_context: Optional[bool] = None,
+    add_session_state_to_context: Optional[bool] = None,
     metadata: Optional[Dict[str, Any]] = None,
     debug_mode: Optional[bool] = None,
     **kwargs: Any,
@@ -386,6 +392,8 @@ def print_response_stream(
             knowledge_filters=knowledge_filters,
             add_history_to_context=add_history_to_context,
             dependencies=dependencies,
+            add_dependencies_to_context=add_dependencies_to_context,
+            add_session_state_to_context=add_session_state_to_context,
             metadata=metadata,
             debug_mode=debug_mode,
             yield_run_response=True,
@@ -841,6 +849,8 @@ async def aprint_response(
     knowledge_filters: Optional[Dict[str, Any]] = None,
     add_history_to_context: Optional[bool] = None,
     dependencies: Optional[Dict[str, Any]] = None,
+    add_dependencies_to_context: Optional[bool] = None,
+    add_session_state_to_context: Optional[bool] = None,
     metadata: Optional[Dict[str, Any]] = None,
     debug_mode: Optional[bool] = None,
     **kwargs: Any,
@@ -893,6 +903,8 @@ async def aprint_response(
             knowledge_filters=knowledge_filters,
             add_history_to_context=add_history_to_context,
             dependencies=dependencies,
+            add_dependencies_to_context=add_dependencies_to_context,
+            add_session_state_to_context=add_session_state_to_context,
             metadata=metadata,
             debug_mode=debug_mode,
             **kwargs,
@@ -1120,6 +1132,8 @@ async def aprint_response_stream(
     knowledge_filters: Optional[Dict[str, Any]] = None,
     add_history_to_context: Optional[bool] = None,
     dependencies: Optional[Dict[str, Any]] = None,
+    add_dependencies_to_context: Optional[bool] = None,
+    add_session_state_to_context: Optional[bool] = None,
     metadata: Optional[Dict[str, Any]] = None,
     debug_mode: Optional[bool] = None,
     **kwargs: Any,
@@ -1196,6 +1210,8 @@ async def aprint_response_stream(
             user_id=user_id,
             knowledge_filters=knowledge_filters,
             add_history_to_context=add_history_to_context,
+            add_dependencies_to_context=add_dependencies_to_context,
+            add_session_state_to_context=add_session_state_to_context,
             dependencies=dependencies,
             metadata=metadata,
             debug_mode=debug_mode,

agno/vectordb/base.py

@@ -1,12 +1,12 @@
 from abc import ABC, abstractmethod
 from typing import Any, Dict, List, Optional
 
-from agno.knowledge.document import Document
-
 
 class VectorDb(ABC):
     """Base class for Vector Databases"""
 
+    from agno.knowledge.document import Document
+
     @abstractmethod
     def create(self) -> None:
         raise NotImplementedError

agno/vectordb/langchaindb/langchaindb.py

@@ -63,9 +63,7 @@ class LangChainVectorDb(VectorDb):
         logger.warning("LangChainKnowledgeBase.async_upsert() not supported - please check the vectorstore manually.")
         raise NotImplementedError
 
-    def search(
-        self, query: str, num_documents: Optional[int] = None, filters: Optional[Dict[str, Any]] = None
-    ) -> List[Document]:
+    def search(self, query: str, limit: int = 5, filters: Optional[Dict[str, Any]] = None) -> List[Document]:
         """Returns relevant documents matching the query"""
 
         try:
@@ -79,7 +77,7 @@ class LangChainVectorDb(VectorDb):
         if self.vectorstore is not None and self.knowledge_retriever is None:
             log_debug("Creating knowledge retriever")
             if self.search_kwargs is None:
-                self.search_kwargs = {"k": num_documents}
+                self.search_kwargs = {"k": limit}
             if filters is not None:
                 self.search_kwargs.update(filters)
             self.knowledge_retriever = self.vectorstore.as_retriever(search_kwargs=self.search_kwargs)
@@ -91,7 +89,7 @@ class LangChainVectorDb(VectorDb):
         if not isinstance(self.knowledge_retriever, BaseRetriever):
             raise ValueError(f"Knowledge retriever is not of type BaseRetriever: {self.knowledge_retriever}")
 
-        log_debug(f"Getting {num_documents} relevant documents for query: {query}")
+        log_debug(f"Getting {limit} relevant documents for query: {query}")
         lc_documents: List[LangChainDocument] = self.knowledge_retriever.invoke(input=query)
         documents = []
         for lc_doc in lc_documents:
@@ -104,9 +102,9 @@ class LangChainVectorDb(VectorDb):
         return documents
 
     async def async_search(
-        self, query: str, num_documents: Optional[int] = None, filters: Optional[Dict[str, Any]] = None
+        self, query: str, limit: int = 5, filters: Optional[Dict[str, Any]] = None
     ) -> List[Document]:
-        return self.search(query, num_documents, filters)
+        return self.search(query, limit, filters)
 
     def drop(self) -> None:
         raise NotImplementedError

agno/vectordb/llamaindex/llamaindexdb.py

@@ -17,6 +17,11 @@ class LlamaIndexVectorDb(VectorDb):
     knowledge_retriever: BaseRetriever
     loader: Optional[Callable] = None
 
+    def __init__(self, knowledge_retriever: BaseRetriever, loader: Optional[Callable] = None, **kwargs):
+        super().__init__(**kwargs)
+        self.knowledge_retriever = knowledge_retriever
+        self.loader = loader
+
     def create(self) -> None:
         raise NotImplementedError
 
@@ -53,15 +58,13 @@ class LlamaIndexVectorDb(VectorDb):
         logger.warning("LlamaIndexVectorDb.async_upsert() not supported - please check the vectorstore manually.")
         raise NotImplementedError
 
-    def search(
-        self, query: str, num_documents: Optional[int] = None, filters: Optional[Dict[str, Any]] = None
-    ) -> List[Document]:
+    def search(self, query: str, limit: int = 5, filters: Optional[Dict[str, Any]] = None) -> List[Document]:
         """
         Returns relevant documents matching the query.
 
         Args:
             query (str): The query string to search for.
-            num_documents (Optional[int]): The maximum number of documents to return. Defaults to None.
+            limit (int): The maximum number of documents to return. Defaults to 5.
             filters (Optional[Dict[str, Any]]): Filters to apply to the search. Defaults to None.
 
         Returns:
@@ -73,8 +76,8 @@ class LlamaIndexVectorDb(VectorDb):
             raise ValueError(f"Knowledge retriever is not of type BaseRetriever: {self.knowledge_retriever}")
 
         lc_documents: List[NodeWithScore] = self.knowledge_retriever.retrieve(query)
-        if num_documents is not None:
-            lc_documents = lc_documents[:num_documents]
+        if limit is not None:
+            lc_documents = lc_documents[:limit]
         documents = []
         for lc_doc in lc_documents:
             documents.append(
@@ -125,3 +128,19 @@ class LlamaIndexVectorDb(VectorDb):
             metadata (Dict[str, Any]): The metadata to update
         """
         raise NotImplementedError("update_metadata not supported for LlamaIndex vectorstores")
+
+    def delete_by_content_id(self, content_id: str) -> bool:
+        """
+        Delete documents by content ID.
+        Not implemented for LlamaIndex wrapper.
+
+        Args:
+            content_id (str): The content ID to delete
+
+        Returns:
+            bool: False as this operation is not supported
+        """
+        logger.warning(
+            "LlamaIndexVectorDb.delete_by_content_id() not supported - please check the vectorstore manually."
+        )
+        return False