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

agno/knowledge/agent.py

@@ -50,6 +50,53 @@ class AgentKnowledge(BaseModel):
         """
         raise NotImplementedError
 
+    def _upsert_warning(self, upsert) -> None:
+        """Log a warning if upsert is not available"""
+        if upsert and self.vector_db is not None and not self.vector_db.upsert_available():
+            log_info(
+                f"Vector db '{self.vector_db.__class__.__module__}' does not support upsert. Falling back to insert."
+            )
+
+    def _load_init(self, recreate: bool, upsert: bool) -> None:
+        """Initial setup for loading knowledge base"""
+        if self.vector_db is None:
+            logger.warning("No vector db provided")
+            return
+
+        if recreate:
+            log_info("Dropping collection")
+            self.vector_db.drop()
+
+        if not self.vector_db.exists():
+            log_info("Creating collection")
+            self.vector_db.create()
+
+        self._upsert_warning(upsert)
+
+    async def _aload_init(self, recreate: bool, upsert: bool) -> None:
+        """Initial async setup for loading knowledge base"""
+        if self.vector_db is None:
+            logger.warning("No vector db provided")
+            return
+
+        if recreate:
+            log_info("Dropping collection")
+            try:
+                await self.vector_db.async_drop()
+            except NotImplementedError:
+                logger.warning("Vector db does not support async drop, falling back to sync drop")
+                self.vector_db.drop()
+
+        if not self.vector_db.exists():
+            log_info("Creating collection")
+            try:
+                await self.vector_db.async_create()
+            except NotImplementedError:
+                logger.warning("Vector db does not support async create, falling back to sync create")
+                self.vector_db.create()
+
+        self._upsert_warning(upsert)
+
     def search(
         self, query: str, num_documents: Optional[int] = None, filters: Optional[Dict[str, Any]] = None
     ) -> List[Document]:
@@ -80,7 +127,7 @@ class AgentKnowledge(BaseModel):
             try:
                 return await self.vector_db.async_search(query=query, limit=_num_documents, filters=filters)
             except NotImplementedError:
-                logger.info("Vector db does not support async search")
+                log_info("Vector db does not support async search")
                 return self.search(query=query, num_documents=_num_documents, filters=filters)
         except Exception as e:
             logger.error(f"Error searching for documents: {e}")
@@ -99,18 +146,10 @@ class AgentKnowledge(BaseModel):
             upsert (bool): If True, upserts documents to the vector db. Defaults to False.
             skip_existing (bool): If True, skips documents which already exist in the vector db when inserting. Defaults to True.
         """
+        self._load_init(recreate, upsert)
         if self.vector_db is None:
-            logger.warning("No vector db provided")
             return
 
-        if recreate:
-            log_info("Dropping collection")
-            self.vector_db.drop()
-
-        if not self.vector_db.exists():
-            log_info("Creating collection")
-            self.vector_db.create()
-
         log_info("Loading knowledge base")
         num_documents = 0
         for document_list in self.document_lists:
@@ -123,8 +162,7 @@ class AgentKnowledge(BaseModel):
 
             # Upsert documents if upsert is True and vector db supports upsert
             if upsert and self.vector_db.upsert_available():
-                for doc in document_list:
-                    self.vector_db.upsert(documents=[doc], filters=doc.meta_data)
+                self.vector_db.upsert(documents=documents_to_load, filters=doc.meta_data)
             # Insert documents
             else:
                 # Filter out documents which already exist in the vector db
@@ -133,11 +171,10 @@ class AgentKnowledge(BaseModel):
                     documents_to_load = self.filter_existing_documents(document_list)
 
                 if documents_to_load:
-                    for doc in documents_to_load:
-                        self.vector_db.insert(documents=[doc], filters=doc.meta_data)
+                    self.vector_db.insert(documents=documents_to_load, filters=doc.meta_data)
 
             num_documents += len(documents_to_load)
-            log_info(f"Added {len(documents_to_load)} documents to knowledge base")
+        log_info(f"Added {num_documents} documents to knowledge base")
 
     async def aload(
         self,
@@ -152,19 +189,10 @@ class AgentKnowledge(BaseModel):
             upsert (bool): If True, upserts documents to the vector db. Defaults to False.
             skip_existing (bool): If True, skips documents which already exist in the vector db when inserting. Defaults to True.
         """
-
+        await self._aload_init(recreate, upsert)
         if self.vector_db is None:
-            logger.warning("No vector db provided")
             return
 
-        if recreate:
-            log_info("Dropping collection")
-            await self.vector_db.async_drop()
-
-        if not await self.vector_db.async_exists():
-            log_info("Creating collection")
-            await self.vector_db.async_create()
-
         log_info("Loading knowledge base")
         num_documents = 0
         document_iterator = self.async_document_lists
@@ -177,8 +205,7 @@ class AgentKnowledge(BaseModel):
 
             # Upsert documents if upsert is True and vector db supports upsert
             if upsert and self.vector_db.upsert_available():
-                for doc in document_list:
-                    await self.vector_db.async_upsert(documents=[doc], filters=doc.meta_data)
+                await self.vector_db.async_upsert(documents=documents_to_load, filters=doc.meta_data)
             # Insert documents
             else:
                 # Filter out documents which already exist in the vector db
@@ -187,11 +214,10 @@ class AgentKnowledge(BaseModel):
                     documents_to_load = await self.async_filter_existing_documents(document_list)
 
                 if documents_to_load:
-                    for doc in documents_to_load:
-                        await self.vector_db.async_insert(documents=[doc], filters=doc.meta_data)
+                    await self.vector_db.async_insert(documents=documents_to_load, filters=doc.meta_data)
 
             num_documents += len(documents_to_load)
-            log_info(f"Added {len(documents_to_load)} documents to knowledge base")
+        log_info(f"Added {num_documents} documents to knowledge base")
 
     def load_documents(
         self,
@@ -208,15 +234,11 @@ class AgentKnowledge(BaseModel):
             skip_existing (bool): If True, skips documents which already exist in the vector db when inserting. Defaults to True.
             filters (Optional[Dict[str, Any]]): Filters to add to each row that can be used to limit results during querying. Defaults to None.
         """
-
-        log_info("Loading knowledge base")
+        self._load_init(recreate=False, upsert=upsert)
         if self.vector_db is None:
-            logger.warning("No vector db provided")
             return
-
-        log_debug("Creating collection")
-        self.vector_db.create()
-
+        
+        log_info("Loading knowledge base")
         # Upsert documents if upsert is True
         if upsert and self.vector_db.upsert_available():
             self.vector_db.upsert(documents=documents, filters=filters)
@@ -251,17 +273,11 @@ class AgentKnowledge(BaseModel):
             skip_existing (bool): If True, skips documents which already exist in the vector db when inserting. Defaults to True.
             filters (Optional[Dict[str, Any]]): Filters to add to each row that can be used to limit results during querying. Defaults to None.
         """
-        log_info("Loading knowledge base")
+        await self._aload_init(recreate=False, upsert=upsert)
         if self.vector_db is None:
-            logger.warning("No vector db provided")
             return
 
-        log_debug("Creating collection")
-        try:
-            await self.vector_db.async_create()
-        except NotImplementedError:
-            logger.warning("Vector db does not support async create")
-            self.vector_db.create()
+        log_info("Loading knowledge base")
 
         # Upsert documents if upsert is True
         if upsert and self.vector_db.upsert_available():
@@ -302,7 +318,7 @@ class AgentKnowledge(BaseModel):
             else:
                 log_info("No new documents to load")
 
-    def add_document_to_knowledge_base(
+    def load_document(
         self,
         document: Document,
         upsert: bool = False,
@@ -414,8 +430,6 @@ class AgentKnowledge(BaseModel):
         Returns:
             List[Document]: Filtered list of documents that don't exist in the database
         """
-        from agno.utils.log import log_debug, log_info
-
         if not self.vector_db:
             log_debug("No vector database configured, skipping document filtering")
             return documents
@@ -556,20 +570,9 @@ class AgentKnowledge(BaseModel):
             self._track_metadata_structure(metadata)
 
         # 3. Prepare vector DB
+        self._load_init(recreate, upsert=False)
         if self.vector_db is None:
-            logger.warning("Cannot load file: No vector db provided.")
             return False
-
-        # Recreate collection if requested
-        if recreate:
-            # log_info(f"Recreating collection.")
-            self.vector_db.drop()
-
-        # Create collection if it doesn't exist
-        if not self.vector_db.exists():
-            # log_info(f"Collection does not exist. Creating.")
-            self.vector_db.create()
-
         return True
 
     async def aprepare_load(
@@ -604,20 +607,9 @@ class AgentKnowledge(BaseModel):
             self._track_metadata_structure(metadata)
 
         # 3. Prepare vector DB
+        await self._aload_init(recreate, upsert=False)
         if self.vector_db is None:
-            logger.warning("Cannot load file: No vector db provided.")
             return False
-
-        # Recreate collection if requested
-        if recreate:
-            log_info("Recreating collection.")
-            await self.vector_db.async_drop()
-
-        # Create collection if it doesn't exist
-        if not await self.vector_db.async_exists():
-            log_info("Collection does not exist. Creating.")
-            await self.vector_db.async_create()
-
         return True
 
     def process_documents(
@@ -642,6 +634,8 @@ class AgentKnowledge(BaseModel):
 
         log_info(f"Loading {len(documents)} documents from {source_info} with metadata: {metadata}")
 
+        self._upsert_warning(upsert)
+
         # Decide loading strategy: upsert or insert (with optional skip)
         if upsert and self.vector_db.upsert_available():  # type: ignore
             log_debug(f"Upserting {len(documents)} documents.")  # type: ignore
@@ -681,6 +675,8 @@ class AgentKnowledge(BaseModel):
             logger.warning(f"No documents were read from {source_info}")
             return
 
+        self._upsert_warning(upsert)
+
         log_info(f"Loading {len(documents)} documents from {source_info} with metadata: {metadata}")
 
         # Decide loading strategy: upsert or insert (with optional skip)

agno/knowledge/pdf.py

@@ -2,15 +2,22 @@ from pathlib import Path
 from typing import Any, AsyncIterator, Dict, Iterator, List, Optional, Union
 
 from pydantic import Field
+from typing_extensions import TypedDict
 
 from agno.document import Document
 from agno.document.reader.pdf_reader import PDFImageReader, PDFReader
 from agno.knowledge.agent import AgentKnowledge
-from agno.utils.log import log_info, logger
+from agno.utils.log import log_error, log_info, logger
+
+
+class PDFConfig(TypedDict, total=False):
+    path: str
+    password: Optional[str]
+    metadata: Optional[Dict[str, Any]]
 
 
 class PDFKnowledgeBase(AgentKnowledge):
-    path: Optional[Union[str, Path, List[Dict[str, Union[str, Dict[str, Any]]]]]] = None
+    path: Optional[Union[str, Path, List[PDFConfig]]] = None
     formats: List[str] = [".pdf"]
     exclude_files: List[str] = Field(default_factory=list)
     reader: Union[PDFReader, PDFImageReader] = PDFReader()
@@ -24,19 +31,21 @@ class PDFKnowledgeBase(AgentKnowledge):
         if isinstance(self.path, list):
             for item in self.path:
                 if isinstance(item, dict) and "path" in item:
-                    # Handle path with metadata
                     file_path = item["path"]
                     config = item.get("metadata", {})
+                    file_password = item.get("password")
+                    if file_password is not None and not isinstance(file_password, str):
+                        file_password = None
+
                     _pdf_path = Path(file_path)  # type: ignore
                     if self._is_valid_pdf(_pdf_path):
-                        documents = self.reader.read(pdf=_pdf_path)
+                        documents = self.reader.read(pdf=_pdf_path, password=file_password)
                         if config:
                             for doc in documents:
                                 log_info(f"Adding metadata {config} to document: {doc.name}")
                                 doc.meta_data.update(config)  # type: ignore
                         yield documents
         else:
-            # Handle single path
             _pdf_path = Path(self.path)
             if _pdf_path.is_dir():
                 for _pdf in _pdf_path.glob("**/*.pdf"):
@@ -47,7 +56,19 @@ class PDFKnowledgeBase(AgentKnowledge):
 
     def _is_valid_pdf(self, path: Path) -> bool:
         """Helper to check if path is a valid PDF file."""
-        return path.exists() and path.is_file() and path.suffix == ".pdf" and path.name not in self.exclude_files
+        if not path.exists():
+            log_error(f"PDF file not found: {path}")
+            return False
+        if not path.is_file():
+            log_error(f"Path is not a file: {path}")
+            return False
+        if path.suffix != ".pdf":
+            log_error(f"File is not a PDF: {path}")
+            return False
+        if path.name in self.exclude_files:
+            log_error(f"PDF file excluded: {path}")
+            return False
+        return True
 
     @property
     async def async_document_lists(self) -> AsyncIterator[List[Document]]:
@@ -58,12 +79,15 @@ class PDFKnowledgeBase(AgentKnowledge):
         if isinstance(self.path, list):
             for item in self.path:
                 if isinstance(item, dict) and "path" in item:
-                    # Handle path with metadata
                     file_path = item["path"]
                     config = item.get("metadata", {})
+                    file_password = item.get("password")
+                    if file_password is not None and not isinstance(file_password, str):
+                        file_password = None
+
                     _pdf_path = Path(file_path)  # type: ignore
                     if self._is_valid_pdf(_pdf_path):
-                        documents = await self.reader.async_read(pdf=_pdf_path)
+                        documents = await self.reader.async_read(pdf=_pdf_path, password=file_password)
                         if config:
                             for doc in documents:
                                 log_info(f"Adding metadata {config} to document: {doc.name}")

agno/knowledge/pdf_url.py

@@ -19,18 +19,22 @@ class PDFUrlKnowledgeBase(AgentKnowledge):
 
         for item in self.urls:
             if isinstance(item, dict) and "url" in item:
-                # Handle URL with metadata
+                # Handle URL with metadata/password
                 url = item["url"]
                 config = item.get("metadata", {})
+                pdf_password = item.get("password")
+                if pdf_password is not None and not isinstance(pdf_password, str):
+                    pdf_password = None
+
                 if self._is_valid_url(url):  # type: ignore
-                    documents = self.reader.read(url=url)  # type: ignore
+                    documents = self.reader.read(url=url, password=pdf_password)  # type: ignore
                     if config:
                         for doc in documents:
                             log_info(f"Adding metadata {config} to document from URL: {url}")
                             doc.meta_data.update(config)  # type: ignore
                     yield documents
             else:
-                # Handle simple URL
+                # Handle simple URL - no password
                 if self._is_valid_url(item):  # type: ignore
                     yield self.reader.read(url=item)  # type: ignore
 
@@ -49,11 +53,15 @@ class PDFUrlKnowledgeBase(AgentKnowledge):
 
         for item in self.urls:
             if isinstance(item, dict) and "url" in item:
-                # Handle URL with metadata
+                # Handle URL with metadata/password
                 url = item["url"]
                 config = item.get("metadata", {})
+                pdf_password = item.get("password")
+                if pdf_password is not None and not isinstance(pdf_password, str):
+                    pdf_password = None
+
                 if self._is_valid_url(url):  # type: ignore
-                    documents = await self.reader.async_read(url=url)  # type: ignore
+                    documents = await self.reader.async_read(url=url, password=pdf_password)  # type: ignore
                     if config:
                         for doc in documents:
                             log_info(f"Adding metadata {config} to document from URL: {url}")

agno/models/openai/responses.py

@@ -78,6 +78,10 @@ class OpenAIResponses(Model):
         }
     )
 
+    def _using_reasoning_model(self) -> bool:
+        """Return True if the contextual used model is a known reasoning model."""
+        return self.id.startswith("o3") or self.id.startswith("o4-mini") or self.id.startswith("gpt-5")
+
     def _get_client_params(self) -> Dict[str, Any]:
         """
         Get client parameters for API requests.
@@ -221,7 +225,7 @@ class OpenAIResponses(Model):
             request_params["tool_choice"] = tool_choice
 
         # Handle reasoning tools for o3 and o4-mini models
-        if (self.id.startswith("o3") or self.id.startswith("o4-mini")) and messages is not None:
+        if self._using_reasoning_model() and messages is not None:
             request_params["store"] = True
 
             # Check if the last assistant message has a previous_response_id to continue from
@@ -352,6 +356,22 @@ class OpenAIResponses(Model):
             Dict[str, Any]: The formatted message.
         """
         formatted_messages: List[Dict[str, Any]] = []
+
+        if self._using_reasoning_model():
+            # 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
+            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 message in messages:
             if message.role in ["user", "system"]:
                 message_dict: Dict[str, Any] = {
@@ -384,6 +404,15 @@ class OpenAIResponses(Model):
                         {"type": "function_call_output", "call_id": message.tool_call_id, "output": message.content}
                     )
             elif message.tool_calls is not None and len(message.tool_calls) > 0:
+                if self._using_reasoning_model():
+                    # Only include prior function_call items when we are NOT using
+                    # previous_response_id. When previous_response_id is present, the
+                    # Responses API already knows about earlier output items (including
+                    # reasoning/function_call), and re-sending them can trigger validation
+                    # errors (e.g., missing required reasoning item).
+                    if previous_response_id is not None:
+                        continue
+
                 for tool_call in message.tool_calls:
                     formatted_messages.append(
                         {

agno/run/response.py

@@ -17,6 +17,7 @@ class RunEvent(str, Enum):
 
     run_started = "RunStarted"
     run_response_content = "RunResponseContent"
+    run_intermediate_response_content = "RunIntermediateResponseContent"
     run_completed = "RunCompleted"
     run_error = "RunError"
     run_cancelled = "RunCancelled"
@@ -92,6 +93,13 @@ class RunResponseContentEvent(BaseAgentRunResponseEvent):
     extra_data: Optional[RunResponseExtraData] = None
 
 
+@dataclass
+class IntermediateRunResponseContentEvent(BaseAgentRunResponseEvent):
+    event: str = RunEvent.run_intermediate_response_content.value
+    content: Optional[Any] = None
+    content_type: str = "str"
+
+
 @dataclass
 class RunResponseCompletedEvent(BaseAgentRunResponseEvent):
     event: str = RunEvent.run_completed.value
@@ -207,6 +215,7 @@ class OutputModelResponseCompletedEvent(BaseAgentRunResponseEvent):
 RunResponseEvent = Union[
     RunResponseStartedEvent,
     RunResponseContentEvent,
+    IntermediateRunResponseContentEvent,
     RunResponseCompletedEvent,
     RunResponseErrorEvent,
     RunResponseCancelledEvent,
@@ -230,6 +239,7 @@ RunResponseEvent = Union[
 RUN_EVENT_TYPE_REGISTRY = {
     RunEvent.run_started.value: RunResponseStartedEvent,
     RunEvent.run_response_content.value: RunResponseContentEvent,
+    RunEvent.run_intermediate_response_content.value: IntermediateRunResponseContentEvent,
     RunEvent.run_completed.value: RunResponseCompletedEvent,
     RunEvent.run_error.value: RunResponseErrorEvent,
     RunEvent.run_cancelled.value: RunResponseCancelledEvent,

agno/run/team.py

@@ -17,6 +17,7 @@ class TeamRunEvent(str, Enum):
 
     run_started = "TeamRunStarted"
     run_response_content = "TeamRunResponseContent"
+    run_intermediate_response_content = "TeamRunIntermediateResponseContent"
     run_completed = "TeamRunCompleted"
     run_error = "TeamRunError"
     run_cancelled = "TeamRunCancelled"
@@ -94,6 +95,13 @@ class RunResponseContentEvent(BaseTeamRunResponseEvent):
     extra_data: Optional[RunResponseExtraData] = None
 
 
+@dataclass
+class IntermediateRunResponseContentEvent(BaseTeamRunResponseEvent):
+    event: str = TeamRunEvent.run_intermediate_response_content.value
+    content: Optional[Any] = None
+    content_type: str = "str"
+
+
 @dataclass
 class RunResponseCompletedEvent(BaseTeamRunResponseEvent):
     event: str = TeamRunEvent.run_completed.value
@@ -191,6 +199,7 @@ class OutputModelResponseCompletedEvent(BaseTeamRunResponseEvent):
 TeamRunResponseEvent = Union[
     RunResponseStartedEvent,
     RunResponseContentEvent,
+    IntermediateRunResponseContentEvent,
     RunResponseCompletedEvent,
     RunResponseErrorEvent,
     RunResponseCancelledEvent,
@@ -211,6 +220,7 @@ TeamRunResponseEvent = Union[
 TEAM_RUN_EVENT_TYPE_REGISTRY = {
     TeamRunEvent.run_started.value: RunResponseStartedEvent,
     TeamRunEvent.run_response_content.value: RunResponseContentEvent,
+    TeamRunEvent.run_intermediate_response_content.value: IntermediateRunResponseContentEvent,
     TeamRunEvent.run_completed.value: RunResponseCompletedEvent,
     TeamRunEvent.run_error.value: RunResponseErrorEvent,
     TeamRunEvent.run_cancelled.value: RunResponseCancelledEvent,