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

agno/knowledge/knowledge.py

@@ -21,7 +21,6 @@ from agno.knowledge.remote_content.remote_content import GCSContent, RemoteConte
 from agno.utils.http import async_fetch_with_retry
 from agno.utils.log import log_debug, log_error, log_info, log_warning
 from agno.utils.string import generate_id
-from agno.vectordb import VectorDb
 
 ContentDict = Dict[str, Union[str, Dict[str, str]]]
 
@@ -39,12 +38,15 @@ class Knowledge:
 
     name: Optional[str] = None
     description: Optional[str] = None
-    vector_db: Optional[VectorDb] = None
+    vector_db: Optional[Any] = None
     contents_db: Optional[BaseDb] = None
     max_results: int = 10
     readers: Optional[Dict[str, Reader]] = None
 
     def __post_init__(self):
+        from agno.vectordb import VectorDb
+
+        self.vector_db = cast(VectorDb, self.vector_db)
         if self.vector_db and not self.vector_db.exists():
             self.vector_db.create()
 
@@ -64,9 +66,12 @@ class Knowledge:
         paths: Optional[List[str]] = None,
         urls: Optional[List[str]] = None,
         metadata: Optional[Dict[str, str]] = None,
+        topics: Optional[List[str]] = None,
+        text_contents: Optional[List[str]] = None,
+        reader: Optional[Reader] = None,
         include: Optional[List[str]] = None,
         exclude: Optional[List[str]] = None,
-        upsert: bool = False,
+        upsert: bool = True,
         skip_if_exists: bool = False,
         remote_content: Optional[RemoteContent] = None,
     ) -> None: ...
@@ -74,7 +79,7 @@ class Knowledge:
     async def add_contents_async(self, *args, **kwargs) -> None:
         if args and isinstance(args[0], list):
             arguments = args[0]
-            upsert = kwargs.get("upsert", False)
+            upsert = kwargs.get("upsert", True)
             skip_if_exists = kwargs.get("skip_if_exists", False)
             for argument in arguments:
                 await self.add_content_async(
@@ -84,6 +89,7 @@ class Knowledge:
                     url=argument.get("url"),
                     metadata=argument.get("metadata"),
                     topics=argument.get("topics"),
+                    text_contents=argument.get("text_contents"),
                     reader=argument.get("reader"),
                     include=argument.get("include"),
                     exclude=argument.get("exclude"),
@@ -97,11 +103,13 @@ class Knowledge:
             metadata = kwargs.get("metadata", {})
             description = kwargs.get("description", [])
             topics = kwargs.get("topics", [])
+            reader = kwargs.get("reader", None)
             paths = kwargs.get("paths", [])
             urls = kwargs.get("urls", [])
+            text_contents = kwargs.get("text_contents", [])
             include = kwargs.get("include")
             exclude = kwargs.get("exclude")
-            upsert = kwargs.get("upsert", False)
+            upsert = kwargs.get("upsert", True)
             skip_if_exists = kwargs.get("skip_if_exists", False)
             remote_content = kwargs.get("remote_content", None)
             for path in paths:
@@ -126,6 +134,19 @@ class Knowledge:
                     upsert=upsert,
                     skip_if_exists=skip_if_exists,
                 )
+            for i, text_content in enumerate(text_contents):
+                content_name = f"{name}_{i}" if name else f"text_content_{i}"
+                log_debug(f"Adding text content: {content_name}")
+                await self.add_content_async(
+                    name=content_name,
+                    description=description,
+                    text_content=text_content,
+                    metadata=metadata,
+                    include=include,
+                    exclude=exclude,
+                    upsert=upsert,
+                    skip_if_exists=skip_if_exists,
+                )
             if topics:
                 await self.add_content_async(
                     name=name,
@@ -136,6 +157,7 @@ class Knowledge:
                     exclude=exclude,
                     upsert=upsert,
                     skip_if_exists=skip_if_exists,
+                    reader=reader,
                 )
 
             if remote_content:
@@ -163,7 +185,7 @@ class Knowledge:
         metadata: Optional[Dict[str, str]] = None,
         include: Optional[List[str]] = None,
         exclude: Optional[List[str]] = None,
-        upsert: bool = False,
+        upsert: bool = True,
         skip_if_exists: bool = False,
     ) -> None: ...
 
@@ -201,7 +223,7 @@ class Knowledge:
         metadata: Optional[Dict[str, str]] = None,
         include: Optional[List[str]] = None,
         exclude: Optional[List[str]] = None,
-        upsert: bool = False,
+        upsert: bool = True,
         skip_if_exists: bool = False,
         reader: Optional[Reader] = None,
         auth: Optional[ContentAuth] = None,
@@ -268,7 +290,7 @@ class Knowledge:
         metadata: Optional[Dict[str, str]] = None,
         include: Optional[List[str]] = None,
         exclude: Optional[List[str]] = None,
-        upsert: bool = False,
+        upsert: bool = True,
         skip_if_exists: bool = False,
         reader: Optional[Reader] = None,
         auth: Optional[ContentAuth] = None,
@@ -291,7 +313,7 @@ class Knowledge:
         include: Optional[List[str]] = None,
         exclude: Optional[List[str]] = None,
         upsert: bool = True,
-        skip_if_exists: bool = True,
+        skip_if_exists: bool = False,
         auth: Optional[ContentAuth] = None,
     ) -> None:
         """
@@ -342,7 +364,11 @@ class Knowledge:
         Returns:
             bool: True if should skip processing, False if should continue
         """
+        from agno.vectordb import VectorDb
+
+        self.vector_db = cast(VectorDb, self.vector_db)
         if self.vector_db and self.vector_db.content_hash_exists(content_hash) and skip_if_exists:
+            log_debug(f"Content already exists: {content_hash}, skipping...")
             return True
 
         return False
@@ -355,6 +381,10 @@ class Knowledge:
         include: Optional[List[str]] = None,
         exclude: Optional[List[str]] = None,
     ):
+        from agno.vectordb import VectorDb
+
+        self.vector_db = cast(VectorDb, self.vector_db)
+
         log_info(f"Adding content from path, {content.id}, {content.name}, {content.path}, {content.description}")
         path = Path(content.path)  # type: ignore
 
@@ -451,6 +481,11 @@ class Knowledge:
         3. Read the content
         4. Prepare and insert the content in the vector database
         """
+
+        from agno.vectordb import VectorDb
+
+        self.vector_db = cast(VectorDb, self.vector_db)
+
         log_info(f"Adding content from URL {content.url}")
         content.file_type = "url"
 
@@ -559,8 +594,12 @@ class Knowledge:
         self,
         content: Content,
         upsert: bool = True,
-        skip_if_exists: bool = True,
+        skip_if_exists: bool = False,
     ):
+        from agno.vectordb import VectorDb
+
+        self.vector_db = cast(VectorDb, self.vector_db)
+
         if content.name:
             name = content.name
         elif content.file_data and content.file_data.content:
@@ -595,10 +634,7 @@ class Knowledge:
         read_documents = []
 
         if isinstance(content.file_data, str):
-            try:
-                content_bytes = content.file_data.encode("utf-8")
-            except UnicodeEncodeError:
-                content_bytes = content.file_data.encode("latin-1")
+            content_bytes = content.file_data.encode("utf-8", errors="replace")
             content_io = io.BytesIO(content_bytes)
 
             if content.reader:
@@ -619,14 +655,7 @@ class Knowledge:
                 if isinstance(content.file_data.content, bytes):
                     content_io = io.BytesIO(content.file_data.content)
                 elif isinstance(content.file_data.content, str):
-                    if self._is_text_mime_type(content.file_data.type):
-                        try:
-                            content_bytes = content.file_data.content.encode("utf-8")
-                        except UnicodeEncodeError:
-                            log_debug(f"UTF-8 encoding failed for {content.file_data.type}, using latin-1")
-                            content_bytes = content.file_data.content.encode("latin-1")
-                    else:
-                        content_bytes = content.file_data.content.encode("latin-1")
+                    content_bytes = content.file_data.content.encode("utf-8", errors="replace")
                     content_io = io.BytesIO(content_bytes)
                 else:
                     content_io = content.file_data.content  # type: ignore
@@ -663,6 +692,9 @@ class Knowledge:
         upsert: bool,
         skip_if_exists: bool,
     ):
+        from agno.vectordb import VectorDb
+
+        self.vector_db = cast(VectorDb, self.vector_db)
         log_info(f"Adding content from topics: {content.topics}")
 
         if content.topics is None:
@@ -896,6 +928,10 @@ class Knowledge:
             await self._handle_vector_db_insert(content_entry, read_documents, upsert)
 
     async def _handle_vector_db_insert(self, content: Content, read_documents, upsert):
+        from agno.vectordb import VectorDb
+
+        self.vector_db = cast(VectorDb, self.vector_db)
+
         if not self.vector_db:
             log_error("No vector database configured")
             content.status = ContentStatus.FAILED
@@ -985,6 +1021,48 @@ class Knowledge:
             )
             return hashlib.sha256(fallback.encode()).hexdigest()
 
+    def _ensure_string_field(self, value: Any, field_name: str, default: str = "") -> str:
+        """
+        Safely ensure a field is a string, handling various edge cases.
+
+        Args:
+            value: The value to convert to string
+            field_name: Name of the field for logging purposes
+            default: Default string value if conversion fails
+
+        Returns:
+            str: A safe string value
+        """
+        # Handle None/falsy values
+        if value is None or value == "":
+            return default
+
+        # Handle unexpected list types (the root cause of our Pydantic warning)
+        if isinstance(value, list):
+            if len(value) == 0:
+                log_debug(f"Empty list found for {field_name}, using default: '{default}'")
+                return default
+            elif len(value) == 1:
+                # Single item list, extract the item
+                log_debug(f"Single-item list found for {field_name}, extracting: '{value[0]}'")
+                return str(value[0]) if value[0] is not None else default
+            else:
+                # Multiple items, join them
+                log_debug(f"Multi-item list found for {field_name}, joining: {value}")
+                return " | ".join(str(item) for item in value if item is not None)
+
+        # Handle other unexpected types
+        if not isinstance(value, str):
+            log_debug(f"Non-string type {type(value)} found for {field_name}, converting: '{value}'")
+            try:
+                return str(value)
+            except Exception as e:
+                log_warning(f"Failed to convert {field_name} to string: {e}, using default")
+                return default
+
+        # Already a string, return as-is
+        return value
+
     def _add_to_contents_db(self, content: Content):
         if self.contents_db:
             created_at = content.created_at if content.created_at else int(time.time())
@@ -997,10 +1075,18 @@ class Knowledge:
                 if content.file_data and content.file_data.type
                 else None
             )
+            # Safely handle string fields with proper type checking
+            safe_name = self._ensure_string_field(content.name, "content.name", default="")
+            safe_description = self._ensure_string_field(content.description, "content.description", default="")
+            safe_linked_to = self._ensure_string_field(self.name, "knowledge.name", default="")
+            safe_status_message = self._ensure_string_field(
+                content.status_message, "content.status_message", default=""
+            )
+
             content_row = KnowledgeRow(
                 id=content.id,
-                name=content.name if content.name else "",
-                description=content.description if content.description else "",
+                name=safe_name,
+                description=safe_description,
                 metadata=content.metadata,
                 type=file_type,
                 size=content.size
@@ -1008,16 +1094,19 @@ class Knowledge:
                 else len(content.file_data.content)
                 if content.file_data and content.file_data.content
                 else None,
-                linked_to=self.name,
+                linked_to=safe_linked_to,
                 access_count=0,
                 status=content.status if content.status else ContentStatus.PROCESSING,
-                status_message="",
+                status_message=safe_status_message,
                 created_at=created_at,
                 updated_at=updated_at,
             )
             self.contents_db.upsert_knowledge_content(knowledge_row=content_row)
 
     def _update_content(self, content: Content) -> Optional[Dict[str, Any]]:
+        from agno.vectordb import VectorDb
+
+        self.vector_db = cast(VectorDb, self.vector_db)
         if self.contents_db:
             if not content.id:
                 log_warning("Content id is required to update Knowledge content")
@@ -1029,18 +1118,25 @@ class Knowledge:
                 log_warning(f"Content row not found for id: {content.id}, cannot update status")
                 return None
 
+            # Apply safe string handling for updates as well
             if content.name is not None:
-                content_row.name = content.name
+                content_row.name = self._ensure_string_field(content.name, "content.name", default="")
             if content.description is not None:
-                content_row.description = content.description
+                content_row.description = self._ensure_string_field(
+                    content.description, "content.description", default=""
+                )
             if content.metadata is not None:
                 content_row.metadata = content.metadata
             if content.status is not None:
                 content_row.status = content.status
             if content.status_message is not None:
-                content_row.status_message = content.status_message if content.status_message else ""
+                content_row.status_message = self._ensure_string_field(
+                    content.status_message, "content.status_message", default=""
+                )
             if content.external_id is not None:
-                content_row.external_id = content.external_id
+                content_row.external_id = self._ensure_string_field(
+                    content.external_id, "content.external_id", default=""
+                )
             content_row.updated_at = int(time.time())
             self.contents_db.upsert_knowledge_content(knowledge_row=content_row)
 
@@ -1053,10 +1149,17 @@ class Knowledge:
             return content_row.to_dict()
 
         else:
-            log_warning(f"Contents DB not found for knowledge base: {self.name}")
+            if self.name:
+                log_warning(f"Contents DB not found for knowledge base: {self.name}")
+            else:
+                log_warning("Contents DB not found for knowledge base")
             return None
 
     async def _process_lightrag_content(self, content: Content, content_type: KnowledgeContentOrigin) -> None:
+        from agno.vectordb import VectorDb
+
+        self.vector_db = cast(VectorDb, self.vector_db)
+
         self._add_to_contents_db(content)
         if content_type == KnowledgeContentOrigin.PATH:
             if content.file_data is None:
@@ -1214,6 +1317,9 @@ class Knowledge:
     ) -> List[Document]:
         """Returns relevant documents matching a query"""
 
+        from agno.vectordb import VectorDb
+
+        self.vector_db = cast(VectorDb, self.vector_db)
         try:
             if self.vector_db is None:
                 log_warning("No vector db provided")
@@ -1231,6 +1337,9 @@ class Knowledge:
     ) -> List[Document]:
         """Returns relevant documents matching a query"""
 
+        from agno.vectordb import VectorDb
+
+        self.vector_db = cast(VectorDb, self.vector_db)
         try:
             if self.vector_db is None:
                 log_warning("No vector db provided")
@@ -1295,18 +1404,27 @@ class Knowledge:
         return valid_filters
 
     def remove_vector_by_id(self, id: str) -> bool:
+        from agno.vectordb import VectorDb
+
+        self.vector_db = cast(VectorDb, self.vector_db)
         if self.vector_db is None:
             log_warning("No vector DB provided")
             return False
         return self.vector_db.delete_by_id(id)
 
     def remove_vectors_by_name(self, name: str) -> bool:
+        from agno.vectordb import VectorDb
+
+        self.vector_db = cast(VectorDb, self.vector_db)
         if self.vector_db is None:
             log_warning("No vector DB provided")
             return False
         return self.vector_db.delete_by_name(name)
 
     def remove_vectors_by_metadata(self, metadata: Dict[str, Any]) -> bool:
+        from agno.vectordb import VectorDb
+
+        self.vector_db = cast(VectorDb, self.vector_db)
         if self.vector_db is None:
             log_warning("No vector DB provided")
             return False
@@ -1393,6 +1511,9 @@ class Knowledge:
         return status, content_row.status_message
 
     def remove_content_by_id(self, content_id: str):
+        from agno.vectordb import VectorDb
+
+        self.vector_db = cast(VectorDb, self.vector_db)
         if self.vector_db is not None:
             if self.vector_db.__class__.__name__ == "LightRag":
                 # For LightRAG, get the content first to find the external_id

agno/knowledge/types.py

@@ -1,4 +1,7 @@
 from enum import Enum
+from typing import Any
+
+from pydantic import BaseModel
 
 
 class ContentType(str, Enum):
@@ -28,3 +31,8 @@ class ContentType(str, Enum):
 def get_content_type_enum(content_type_str: str) -> ContentType:
     """Convert a content type string to ContentType enum."""
     return ContentType(content_type_str)
+
+
+class KnowledgeFilter(BaseModel):
+    key: str
+    value: Any

agno/models/cometapi/__init__.py

@@ -0,0 +1,5 @@
+from agno.models.cometapi.cometapi import CometAPI
+
+__all__ = [
+    "CometAPI",
+]

agno/models/cometapi/cometapi.py

@@ -0,0 +1,57 @@
+from dataclasses import dataclass, field
+from os import getenv
+from typing import List, Optional
+
+import httpx
+
+from agno.models.openai.like import OpenAILike
+from agno.utils.log import log_debug
+
+
+@dataclass
+class CometAPI(OpenAILike):
+    """
+    The CometAPI class provides access to multiple AI model providers
+    (GPT, Claude, Gemini, DeepSeek, etc.) through OpenAI-compatible endpoints.
+
+    Args:
+        id (str): The id of the CometAPI model to use. Default is "gpt-5-mini".
+        name (str): The name for this model. Defaults to "CometAPI".
+        api_key (str): The API key for CometAPI. Defaults to COMETAPI_KEY environment variable.
+        base_url (str): The base URL for CometAPI. Defaults to "https://api.cometapi.com/v1".
+    """
+
+    name: str = "CometAPI"
+    id: str = "gpt-5-mini"
+    api_key: Optional[str] = field(default_factory=lambda: getenv("COMETAPI_KEY"))
+    base_url: str = "https://api.cometapi.com/v1"
+
+    def get_available_models(self) -> List[str]:
+        """
+        Fetch available chat models from CometAPI, filtering out non-chat models.
+
+        Returns:
+            List of available chat model IDs
+        """
+        if not self.api_key:
+            log_debug("No API key provided, returning empty model list")
+            return []
+
+        try:
+            with httpx.Client() as client:
+                response = client.get(
+                    f"{self.base_url}/models",
+                    headers={"Authorization": f"Bearer {self.api_key}", "Accept": "application/json"},
+                    timeout=30.0,
+                )
+                response.raise_for_status()
+
+                data = response.json()
+                all_models = data.get("data", [])
+
+                log_debug(f"Found {len(all_models)} total models")
+                return sorted(all_models)
+
+        except Exception as e:
+            log_debug(f"Error fetching models from CometAPI: {e}")
+            return []

agno/models/google/gemini.py

@@ -16,9 +16,8 @@ from agno.models.message import Citations, Message, UrlCitation
 from agno.models.metrics import Metrics
 from agno.models.response import ModelResponse
 from agno.run.agent import RunOutput
-from agno.utils.gemini import convert_schema, format_function_definitions, format_image_for_message
+from agno.utils.gemini import format_function_definitions, format_image_for_message, prepare_response_schema
 from agno.utils.log import log_debug, log_error, log_info, log_warning
-from agno.utils.models.schema_utils import get_response_schema_for_provider
 
 try:
     from google import genai
@@ -191,12 +190,9 @@ class Gemini(Model):
 
         if response_format is not None and isinstance(response_format, type) and issubclass(response_format, BaseModel):
             config["response_mime_type"] = "application/json"  # type: ignore
-            # Convert Pydantic model to JSON schema, then normalize for Gemini, then convert to Gemini schema format
-
-            # Get the normalized schema for Gemini
-            normalized_schema = get_response_schema_for_provider(response_format, "gemini")
-            gemini_schema = convert_schema(normalized_schema)
-            config["response_schema"] = gemini_schema
+            # Convert Pydantic model using our hybrid approach
+            # This will handle complex schemas with nested models, dicts, and circular refs
+            config["response_schema"] = prepare_response_schema(response_format)
 
         # Add thinking configuration
         thinking_config_params = {}

agno/models/ollama/chat.py

@@ -84,7 +84,8 @@ class Ollama(Model):
         if self.async_client is not None:
             return self.async_client
 
-        return AsyncOllamaClient(**self._get_client_params())
+        self.async_client = AsyncOllamaClient(**self._get_client_params())
+        return self.async_client
 
     def get_request_params(
         self,
@@ -144,6 +145,28 @@ class Ollama(Model):
             "role": message.role,
             "content": message.content,
         }
+
+        if message.role == "assistant" and message.tool_calls is not None:
+            # Format tool calls for assistant messages
+            formatted_tool_calls = []
+            for tool_call in message.tool_calls:
+                if "function" in tool_call:
+                    function_data = tool_call["function"]
+                    formatted_tool_call = {
+                        "id": tool_call.get("id"),
+                        "type": "function",
+                        "function": {
+                            "name": function_data["name"],
+                            "arguments": json.loads(function_data["arguments"])
+                            if isinstance(function_data["arguments"], str)
+                            else function_data["arguments"],
+                        },
+                    }
+                    formatted_tool_calls.append(formatted_tool_call)
+
+            if formatted_tool_calls:
+                _message["tool_calls"] = formatted_tool_calls
+
         if message.role == "user":
             if message.images is not None:
                 message_images = []

agno/models/openai/chat.py

@@ -22,13 +22,8 @@ try:
     from openai import AsyncOpenAI as AsyncOpenAIClient
     from openai import OpenAI as OpenAIClient
     from openai.types import CompletionUsage
-    from openai.types.chat import ChatCompletionAudio
-    from openai.types.chat.chat_completion import ChatCompletion
-    from openai.types.chat.chat_completion_chunk import (
-        ChatCompletionChunk,
-        ChoiceDelta,
-        ChoiceDeltaToolCall,
-    )
+    from openai.types.chat import ChatCompletion, ChatCompletionAudio, ChatCompletionChunk
+    from openai.types.chat.chat_completion_chunk import ChoiceDelta, ChoiceDeltaToolCall
 except (ImportError, ModuleNotFoundError):
     raise ImportError("`openai` not installed. Please install using `pip install openai`")
 

agno/models/openai/responses.py

@@ -19,10 +19,7 @@ from agno.utils.models.schema_utils import get_response_schema_for_provider
 
 try:
     from openai import APIConnectionError, APIStatusError, AsyncOpenAI, OpenAI, RateLimitError
-    from openai.types.responses.response import Response
-    from openai.types.responses.response_reasoning_item import ResponseReasoningItem
-    from openai.types.responses.response_stream_event import ResponseStreamEvent
-    from openai.types.responses.response_usage import ResponseUsage
+    from openai.types.responses import Response, ResponseReasoningItem, ResponseStreamEvent, ResponseUsage
 except ImportError as e:
     raise ImportError("`openai` not installed. Please install using `pip install openai -U`") from e
 
@@ -407,21 +404,28 @@ class OpenAIResponses(Model):
         """
         formatted_messages: List[Union[Dict[str, Any], ResponseReasoningItem]] = []
 
-        if self._using_reasoning_model():
+        messages_to_format = messages
+        previous_response_id: Optional[str] = None
+        
+        if self._using_reasoning_model() and self.store is not False:
             # Detect whether we're chaining via previous_response_id. If so, we should NOT
             # re-send prior function_call items; the Responses API already has the state and
             # expects only the corresponding function_call_output items.
-            previous_response_id: Optional[str] = None
-            if self.store is not False:
-                for msg in reversed(messages):
-                    if (
-                        msg.role == "assistant"
-                        and hasattr(msg, "provider_data")
-                        and msg.provider_data
-                        and "response_id" in msg.provider_data
-                    ):
-                        previous_response_id = msg.provider_data["response_id"]
-                        break
+        
+            for msg in reversed(messages):
+                if (
+                    msg.role == "assistant" 
+                    and hasattr(msg, "provider_data") 
+                    and msg.provider_data 
+                    and "response_id" in msg.provider_data
+                ):
+                    previous_response_id = msg.provider_data["response_id"]
+                    msg_index = messages.index(msg)
+                    
+                    # Include messages after this assistant message
+                    messages_to_format = messages[msg_index + 1:]
+                    
+                    break
 
         # Build a mapping from function_call id (fc_*) → call_id (call_*) from prior assistant tool_calls
         fc_id_to_call_id: Dict[str, str] = {}
@@ -434,7 +438,7 @@ class OpenAIResponses(Model):
                     if isinstance(fc_id, str) and isinstance(call_id, str):
                         fc_id_to_call_id[fc_id] = call_id
 
-        for message in messages:
+        for message in messages_to_format:
             if message.role in ["user", "system"]:
                 message_dict: Dict[str, Any] = {
                     "role": self.role_map[message.role],

agno/os/interfaces/agui/agui.py

@@ -19,8 +19,8 @@ class AGUI(BaseInterface):
         self.agent = agent
         self.team = team
 
-        if not self.agent and not self.team:
-            raise ValueError("AGUI requires an agent and a team")
+        if not (self.agent or self.team):
+            raise ValueError("AGUI requires an agent or a team")
 
     def get_router(self, **kwargs) -> APIRouter:
         # Cannot be overridden