agno 2.0.11__py3-none-any.whl → 2.1.1__py3-none-any.whl

agno/knowledge/embedder/openai.py

@@ -140,66 +140,24 @@ class OpenAIEmbedder(Embedder):
             logger.warning(e)
             return [], None
 
-    def get_embeddings_batch(self, texts: List[str], batch_size: int = 100) -> List[List[float]]:
+    async def async_get_embeddings_batch_and_usage(
+        self, texts: List[str]
+    ) -> Tuple[List[List[float]], List[Optional[Dict]]]:
         """
-        Get embeddings for multiple texts in batches.
+        Get embeddings and usage for multiple texts in batches (async version).
 
         Args:
             texts: List of text strings to embed
-            batch_size: Number of texts to process in each API call (max ~2048)
 
         Returns:
-            List of embedding vectors
+            Tuple of (List of embedding vectors, List of usage dictionaries)
         """
         all_embeddings = []
+        all_usage = []
+        logger.info(f"Getting embeddings and usage for {len(texts)} texts in batches of {self.batch_size} (async)")
 
-        for i in range(0, len(texts), batch_size):
-            batch_texts = texts[i : i + batch_size]
-
-            req: Dict[str, Any] = {
-                "input": batch_texts,
-                "model": self.id,
-                "encoding_format": self.encoding_format,
-            }
-            if self.user is not None:
-                req["user"] = self.user
-            if self.id.startswith("text-embedding-3"):
-                req["dimensions"] = self.dimensions
-            if self.request_params:
-                req.update(self.request_params)
-
-            try:
-                response: CreateEmbeddingResponse = self.client.embeddings.create(**req)
-                batch_embeddings = [data.embedding for data in response.data]
-                all_embeddings.extend(batch_embeddings)
-            except Exception as e:
-                logger.warning(f"Error in batch embedding: {e}")
-                # Fallback to individual calls for this batch
-                for text in batch_texts:
-                    try:
-                        embedding = self.get_embedding(text)
-                        all_embeddings.append(embedding)
-                    except Exception as e2:
-                        logger.warning(f"Error in individual embedding fallback: {e2}")
-                        all_embeddings.append([])
-
-        return all_embeddings
-
-    async def async_get_embeddings_batch(self, texts: List[str], batch_size: int = 100) -> List[List[float]]:
-        """
-        Get embeddings for multiple texts in batches (async version).
-
-        Args:
-            texts: List of text strings to embed
-            batch_size: Number of texts to process in each API call (max ~2048)
-
-        Returns:
-            List of embedding vectors
-        """
-        all_embeddings = []
-
-        for i in range(0, len(texts), batch_size):
-            batch_texts = texts[i : i + batch_size]
+        for i in range(0, len(texts), self.batch_size):
+            batch_texts = texts[i : i + self.batch_size]
 
             req: Dict[str, Any] = {
                 "input": batch_texts,
@@ -217,15 +175,21 @@ class OpenAIEmbedder(Embedder):
                 response: CreateEmbeddingResponse = await self.aclient.embeddings.create(**req)
                 batch_embeddings = [data.embedding for data in response.data]
                 all_embeddings.extend(batch_embeddings)
+
+                # For each embedding in the batch, add the same usage information
+                usage_dict = response.usage.model_dump() if response.usage else None
+                all_usage.extend([usage_dict] * len(batch_embeddings))
             except Exception as e:
                 logger.warning(f"Error in async batch embedding: {e}")
-                # Fallback to individual async calls for this batch
+                # Fallback to individual calls for this batch
                 for text in batch_texts:
                     try:
-                        embedding = await self.async_get_embedding(text)
+                        embedding, usage = await self.async_get_embedding_and_usage(text)
                         all_embeddings.append(embedding)
+                        all_usage.append(usage)
                     except Exception as e2:
                         logger.warning(f"Error in individual async embedding fallback: {e2}")
                         all_embeddings.append([])
+                        all_usage.append(None)
 
-        return all_embeddings
+        return all_embeddings, all_usage

agno/knowledge/embedder/voyageai.py

@@ -30,12 +30,13 @@ class VoyageAIEmbedder(Embedder):
         if self.voyage_client:
             return self.voyage_client
 
-        _client_params = {
-            "api_key": self.api_key,
-            "max_retries": self.max_retries,
-            "timeout": self.timeout,
-        }
-        _client_params = {k: v for k, v in _client_params.items() if v is not None}
+        _client_params: Dict[str, Any] = {}
+        if self.api_key is not None:
+            _client_params["api_key"] = self.api_key
+        if self.max_retries is not None:
+            _client_params["max_retries"] = self.max_retries
+        if self.timeout is not None:
+            _client_params["timeout"] = self.timeout
         if self.client_params:
             _client_params.update(self.client_params)
         self.voyage_client = VoyageClient(**_client_params)
@@ -46,12 +47,13 @@ class VoyageAIEmbedder(Embedder):
         if self.async_client:
             return self.async_client
 
-        _client_params = {
-            "api_key": self.api_key,
-            "max_retries": self.max_retries,
-            "timeout": self.timeout,
-        }
-        _client_params = {k: v for k, v in _client_params.items() if v is not None}
+        _client_params: Dict[str, Any] = {}
+        if self.api_key is not None:
+            _client_params["api_key"] = self.api_key
+        if self.max_retries is not None:
+            _client_params["max_retries"] = self.max_retries
+        if self.timeout is not None:
+            _client_params["timeout"] = self.timeout
         if self.client_params:
             _client_params.update(self.client_params)
         self.async_client = AsyncVoyageClient(**_client_params)
@@ -69,7 +71,8 @@ class VoyageAIEmbedder(Embedder):
     def get_embedding(self, text: str) -> List[float]:
         response: EmbeddingsObject = self._response(text=text)
         try:
-            return response.embeddings[0]
+            embedding = response.embeddings[0]
+            return [float(x) for x in embedding]  # Ensure all values are float
         except Exception as e:
             logger.warning(e)
             return []
@@ -79,7 +82,7 @@ class VoyageAIEmbedder(Embedder):
 
         embedding = response.embeddings[0]
         usage = {"total_tokens": response.total_tokens}
-        return embedding, usage
+        return [float(x) for x in embedding], usage
 
     async def _async_response(self, text: str) -> EmbeddingsObject:
         """Async version of _response using AsyncVoyageClient."""
@@ -95,7 +98,8 @@ class VoyageAIEmbedder(Embedder):
         """Async version of get_embedding."""
         try:
             response: EmbeddingsObject = await self._async_response(text=text)
-            return response.embeddings[0]
+            embedding = response.embeddings[0]
+            return [float(x) for x in embedding]  # Ensure all values are float
         except Exception as e:
             logger.warning(f"Error getting embedding: {e}")
             return []
@@ -106,7 +110,56 @@ class VoyageAIEmbedder(Embedder):
             response: EmbeddingsObject = await self._async_response(text=text)
             embedding = response.embeddings[0]
             usage = {"total_tokens": response.total_tokens}
-            return embedding, usage
+            return [float(x) for x in embedding], usage
         except Exception as e:
             logger.warning(f"Error getting embedding and usage: {e}")
             return [], None
+
+    async def async_get_embeddings_batch_and_usage(
+        self, texts: List[str]
+    ) -> Tuple[List[List[float]], List[Optional[Dict]]]:
+        """
+        Get embeddings and usage for multiple texts in batches.
+
+        Args:
+            texts: List of text strings to embed
+
+        Returns:
+            Tuple of (List of embedding vectors, List of usage dictionaries)
+        """
+        all_embeddings: List[List[float]] = []
+        all_usage: List[Optional[Dict]] = []
+        logger.info(f"Getting embeddings and usage for {len(texts)} texts in batches of {self.batch_size}")
+
+        for i in range(0, len(texts), self.batch_size):
+            batch_texts = texts[i : i + self.batch_size]
+
+            req: Dict[str, Any] = {
+                "texts": batch_texts,
+                "model": self.id,
+            }
+            if self.request_params:
+                req.update(self.request_params)
+
+            try:
+                response: EmbeddingsObject = await self.aclient.embed(**req)
+                batch_embeddings = [[float(x) for x in emb] for emb in response.embeddings]
+                all_embeddings.extend(batch_embeddings)
+
+                # For each embedding in the batch, add the same usage information
+                usage_dict = {"total_tokens": response.total_tokens}
+                all_usage.extend([usage_dict] * len(batch_embeddings))
+            except Exception as e:
+                logger.warning(f"Error in async batch embedding: {e}")
+                # Fallback to individual calls for this batch
+                for text in batch_texts:
+                    try:
+                        embedding, usage = await self.async_get_embedding_and_usage(text)
+                        all_embeddings.append(embedding)
+                        all_usage.append(usage)
+                    except Exception as e2:
+                        logger.warning(f"Error in individual async embedding fallback: {e2}")
+                        all_embeddings.append([])
+                        all_usage.append(None)
+
+        return all_embeddings, all_usage

agno/knowledge/knowledge.py

@@ -89,7 +89,7 @@ class Knowledge:
                     url=argument.get("url"),
                     metadata=argument.get("metadata"),
                     topics=argument.get("topics"),
-                    text_contents=argument.get("text_contents"),
+                    text_content=argument.get("text_content"),
                     reader=argument.get("reader"),
                     include=argument.get("include"),
                     exclude=argument.get("exclude"),
@@ -251,7 +251,9 @@ class Knowledge:
     ) -> None:
         # Validation: At least one of the parameters must be provided
         if all(argument is None for argument in [path, url, text_content, topics, remote_content]):
-            log_info("At least one of 'path', 'url', 'text_content', 'topics', or 'remote_content' must be provided.")
+            log_warning(
+                "At least one of 'path', 'url', 'text_content', 'topics', or 'remote_content' must be provided."
+            )
             return
 
         if not skip_if_exists:
@@ -534,7 +536,6 @@ class Knowledge:
         reader = content.reader
         name = content.name if content.name else content.url
         # Else select based on file extension
-
         if reader is None:
             if file_extension == ".csv":
                 name = basename(parsed_url.path) or "data.csv"
@@ -570,6 +571,7 @@ class Knowledge:
                         read_documents = reader.read(bytes_content, name=name)
                     else:
                         read_documents = reader.read(content.url, name=name)
+
         except Exception as e:
             log_error(f"Error reading URL: {content.url} - {str(e)}")
             content.status = ContentStatus.FAILED
@@ -580,7 +582,6 @@ class Knowledge:
         # 6. Chunk documents if needed
         if reader and not reader.chunk:
             read_documents = await reader.chunk_documents_async(read_documents)
-
         # 7. Prepare and insert the content in the vector database
         file_size = 0
         if read_documents:
@@ -1356,6 +1357,12 @@ class Knowledge:
             log_error(f"Error searching for documents: {e}")
             return []
 
+    def get_valid_filters(self) -> Set[str]:
+        if self.valid_metadata_filters is None:
+            self.valid_metadata_filters = set()
+        self.valid_metadata_filters.update(self._get_filters_from_db)
+        return self.valid_metadata_filters
+
     def validate_filters(self, filters: Optional[Dict[str, Any]]) -> Tuple[Dict[str, Any], List[str]]:
         if self.valid_metadata_filters is None:
             self.valid_metadata_filters = set()

agno/knowledge/reader/pdf_reader.py

@@ -117,6 +117,10 @@ def _clean_page_numbers(
     page_numbers = [find_page_number(content) for content in page_content_list]
     if all(x is None or x > 5 for x in page_numbers):
         # This approach won't work reliably for higher page numbers.
+        page_content_list = [
+            f"\n{page_content_list[i]}\n{extra_content[i]}" if extra_content else page_content_list[i]
+            for i in range(len(page_content_list))
+        ]
         return page_content_list, None
 
     # Possible range shifts to detect page numbering
@@ -261,7 +265,6 @@ class BasePDFReader(Reader):
 
         if self.chunk:
             return self._build_chunked_documents(documents)
-
         return documents
 
     def _pdf_reader_to_documents(
@@ -339,8 +342,6 @@ class PDFReader(BasePDFReader):
         except Exception:
             doc_name = "pdf"
 
-        log_info(f"Reading: {doc_name}")
-
         try:
             DocumentReader(pdf)
         except PdfStreamError as e:

agno/knowledge/reader/website_reader.py

@@ -112,7 +112,8 @@ class WebsiteReader(Reader):
             if tag.name in ["article", "main", "section"]:
                 return True
 
-            classes = tag.get("class", [])
+            classes_attr = tag.get("class")
+            classes: List[str] = classes_attr if isinstance(classes_attr, list) else []
             content_classes = ["content", "main-content", "post-content", "entry-content", "article-body"]
             if any(cls in content_classes for cls in classes):
                 return True
@@ -126,7 +127,7 @@ class WebsiteReader(Reader):
 
         # Try to find main content element
         element = soup.find(match)
-        if element:
+        if element and hasattr(element, "find_all"):
             # Remove common unwanted elements from the found content
             for unwanted in element.find_all(["script", "style", "nav", "header", "footer"]):
                 unwanted.decompose()

agno/models/base.py

@@ -715,6 +715,7 @@ class Model(ABC):
             assistant_message = Message(role=self.assistant_message_role)
             # Create assistant message and stream data
             stream_data = MessageData()
+            model_response = ModelResponse()
             if stream_model_response:
                 # Generate response
                 yield from self.process_response_stream(
@@ -744,7 +745,6 @@ class Model(ABC):
                     assistant_message.tool_calls = self.parse_tool_calls(stream_data.response_tool_calls)
 
             else:
-                model_response = ModelResponse()
                 self._process_model_response(
                     messages=messages,
                     assistant_message=assistant_message,
@@ -784,6 +784,10 @@ class Model(ABC):
                     self.format_function_call_results(
                         messages=messages, function_call_results=function_call_results, **stream_data.extra
                     )
+                elif model_response and model_response.extra is not None:
+                    self.format_function_call_results(
+                        messages=messages, function_call_results=function_call_results, **model_response.extra
+                    )
                 else:
                     self.format_function_call_results(messages=messages, function_call_results=function_call_results)
 
@@ -879,9 +883,10 @@ class Model(ABC):
             # Create assistant message and stream data
             assistant_message = Message(role=self.assistant_message_role)
             stream_data = MessageData()
+            model_response = ModelResponse()
             if stream_model_response:
                 # Generate response
-                async for response in self.aprocess_response_stream(
+                async for model_response in self.aprocess_response_stream(
                     messages=messages,
                     assistant_message=assistant_message,
                     stream_data=stream_data,
@@ -890,7 +895,7 @@ class Model(ABC):
                     tool_choice=tool_choice or self._tool_choice,
                     run_response=run_response,
                 ):
-                    yield response
+                    yield model_response
 
                 # Populate assistant message from stream data
                 if stream_data.response_content:
@@ -907,7 +912,6 @@ class Model(ABC):
                     assistant_message.tool_calls = self.parse_tool_calls(stream_data.response_tool_calls)
 
             else:
-                model_response = ModelResponse()
                 await self._aprocess_model_response(
                     messages=messages,
                     assistant_message=assistant_message,
@@ -948,6 +952,10 @@ class Model(ABC):
                     self.format_function_call_results(
                         messages=messages, function_call_results=function_call_results, **stream_data.extra
                     )
+                elif model_response and model_response.extra is not None:
+                    self.format_function_call_results(
+                        messages=messages, function_call_results=function_call_results, **model_response.extra or {}
+                    )
                 else:
                     self.format_function_call_results(messages=messages, function_call_results=function_call_results)
 
@@ -1573,30 +1581,35 @@ class Model(ABC):
             *(self.arun_function_call(fc) for fc in function_calls_to_run), return_exceptions=True
         )
 
-        # Process results
+        # Separate async generators from other results for concurrent processing
+        async_generator_results: List[Any] = []
+        non_async_generator_results: List[Any] = []
+
         for result in results:
-            # If result is an exception, skip processing it
             if isinstance(result, BaseException):
-                log_error(f"Error during function call: {result}")
-                raise result
+                non_async_generator_results.append(result)
+                continue
 
-            # Unpack result
             function_call_success, function_call_timer, function_call, function_execution_result = result
 
-            updated_session_state = function_execution_result.updated_session_state
+            # Check if this result contains an async generator
+            if isinstance(function_call.result, (AsyncGeneratorType, AsyncIterator)):
+                async_generator_results.append(result)
+            else:
+                non_async_generator_results.append(result)
 
-            # Handle AgentRunException
-            if isinstance(function_call_success, AgentRunException):
-                a_exc = function_call_success
-                # Update additional messages from function call
-                _handle_agent_exception(a_exc, additional_input)
-                # Set function call success to False if an exception occurred
-                function_call_success = False
+        # Process async generators with real-time event streaming using asyncio.Queue
+        async_generator_outputs: Dict[int, Tuple[Any, str, Optional[BaseException]]] = {}
+        event_queue: asyncio.Queue = asyncio.Queue()
+        active_generators_count: int = len(async_generator_results)
 
-            # Process function call output
-            function_call_output: str = ""
-            if isinstance(function_call.result, (GeneratorType, collections.abc.Iterator)):
-                for item in function_call.result:
+        # Create background tasks for each async generator
+        async def process_async_generator(result, generator_id):
+            function_call_success, function_call_timer, function_call, function_execution_result = result
+            function_call_output = ""
+
+            try:
+                async for item in function_call.result:
                     # This function yields agent/team run events
                     if isinstance(item, tuple(get_args(RunOutputEvent))) or isinstance(
                         item, tuple(get_args(TeamRunOutputEvent))
@@ -1610,17 +1623,102 @@ class Model(ABC):
                                 function_call_output += item.content or ""
 
                             if function_call.function.show_result:
-                                yield ModelResponse(content=item.content)
+                                await event_queue.put(ModelResponse(content=item.content))
                                 continue
 
-                        # Yield the event itself to bubble it up
-                        yield item
+                            if isinstance(item, CustomEvent):
+                                function_call_output += str(item)
+
+                        # Put the event into the queue to be yielded
+                        await event_queue.put(item)
+
+                    # Yield custom events emitted by the tool
                     else:
                         function_call_output += str(item)
                         if function_call.function.show_result:
-                            yield ModelResponse(content=str(item))
-            elif isinstance(function_call.result, (AsyncGeneratorType, collections.abc.AsyncIterator)):
-                async for item in function_call.result:
+                            await event_queue.put(ModelResponse(content=str(item)))
+
+                # Store the final output for this generator
+                async_generator_outputs[generator_id] = (result, function_call_output, None)
+
+            except Exception as e:
+                # Store the exception
+                async_generator_outputs[generator_id] = (result, "", e)
+
+            # Signal that this generator is done
+            await event_queue.put(("GENERATOR_DONE", generator_id))
+
+        # Start all async generator tasks
+        generator_tasks = []
+        for i, result in enumerate(async_generator_results):
+            task = asyncio.create_task(process_async_generator(result, i))
+            generator_tasks.append(task)
+
+        # Stream events from the queue as they arrive
+        completed_generators_count = 0
+        while completed_generators_count < active_generators_count:
+            try:
+                event = await event_queue.get()
+
+                # Check if this is a completion signal
+                if isinstance(event, tuple) and event[0] == "GENERATOR_DONE":
+                    completed_generators_count += 1
+                    continue
+
+                # Yield the actual event
+                yield event
+
+            except Exception as e:
+                log_error(f"Error processing async generator event: {e}")
+                break
+
+        # Now process all results (non-async generators and completed async generators)
+        for i, original_result in enumerate(results):
+            # If result is an exception, skip processing it
+            if isinstance(original_result, BaseException):
+                log_error(f"Error during function call: {original_result}")
+                raise original_result
+
+            # Unpack result
+            function_call_success, function_call_timer, function_call, function_execution_result = original_result
+
+            # Check if this was an async generator that was already processed
+            async_function_call_output = None
+            if isinstance(function_call.result, (AsyncGeneratorType, collections.abc.AsyncIterator)):
+                # Find the corresponding processed result
+                async_gen_index = 0
+                for j, result in enumerate(results[: i + 1]):
+                    if not isinstance(result, BaseException):
+                        _, _, fc, _ = result
+                        if isinstance(fc.result, (AsyncGeneratorType, collections.abc.AsyncIterator)):
+                            if j == i:  # This is our async generator
+                                if async_gen_index in async_generator_outputs:
+                                    _, async_function_call_output, error = async_generator_outputs[async_gen_index]
+                                    if error:
+                                        log_error(f"Error in async generator: {error}")
+                                        raise error
+                                break
+                            async_gen_index += 1
+
+            updated_session_state = function_execution_result.updated_session_state
+
+            # Handle AgentRunException
+            if isinstance(function_call_success, AgentRunException):
+                a_exc = function_call_success
+                # Update additional messages from function call
+                _handle_agent_exception(a_exc, additional_input)
+                # Set function call success to False if an exception occurred
+                function_call_success = False
+
+            # Process function call output
+            function_call_output: str = ""
+
+            # Check if this was an async generator that was already processed
+            if async_function_call_output is not None:
+                function_call_output = async_function_call_output
+                # Events from async generators were already yielded in real-time above
+            elif isinstance(function_call.result, (GeneratorType, collections.abc.Iterator)):
+                for item in function_call.result:
                     # This function yields agent/team run events
                     if isinstance(item, tuple(get_args(RunOutputEvent))) or isinstance(
                         item, tuple(get_args(TeamRunOutputEvent))
@@ -1637,13 +1735,8 @@ class Model(ABC):
                                 yield ModelResponse(content=item.content)
                                 continue
 
-                            if isinstance(item, CustomEvent):
-                                function_call_output += str(item)
-
                         # Yield the event itself to bubble it up
                         yield item
-
-                    # Yield custom events emitted by the tool
                     else:
                         function_call_output += str(item)
                         if function_call.function.show_result:

agno/models/cerebras/cerebras.py

@@ -136,6 +136,7 @@ class Cerebras(Model):
         self,
         tools: Optional[List[Dict[str, Any]]] = None,
         response_format: Optional[Union[Dict, Type[BaseModel]]] = None,
+        **kwargs: Any,
     ) -> Dict[str, Any]:
         """
         Returns keyword arguments for API requests.

agno/models/cerebras/cerebras_openai.py

@@ -25,6 +25,7 @@ class CerebrasOpenAI(OpenAILike):
         response_format: Optional[Union[Dict, Type[BaseModel]]] = None,
         tools: Optional[List[Dict[str, Any]]] = None,
         tool_choice: Optional[Union[str, Dict[str, Any]]] = None,
+        **kwargs: Any,
     ) -> Dict[str, Any]:
         """
         Returns keyword arguments for API requests.

agno/models/dashscope/dashscope.py

@@ -73,6 +73,7 @@ class DashScope(OpenAILike):
         response_format: Optional[Union[Dict, Type[BaseModel]]] = None,
         tools: Optional[List[Dict[str, Any]]] = None,
         tool_choice: Optional[Union[str, Dict[str, Any]]] = None,
+        **kwargs: Any,
     ) -> Dict[str, Any]:
         params = super().get_request_params(response_format=response_format, tools=tools, tool_choice=tool_choice)