agno 2.0.0rc1__py3-none-any.whl → 2.0.0rc2__py3-none-any.whl

agno/knowledge/reader/s3_reader.py

@@ -2,14 +2,15 @@ import asyncio
 from io import BytesIO
 from pathlib import Path
 from typing import List, Optional
-from uuid import uuid4
 
 from agno.knowledge.chunking.fixed import FixedSizeChunking
 from agno.knowledge.chunking.strategy import ChunkingStrategy, ChunkingStrategyType
 from agno.knowledge.document.base import Document
 from agno.knowledge.reader.base import Reader
+from agno.knowledge.reader.pdf_reader import PDFReader
+from agno.knowledge.reader.text_reader import TextReader
 from agno.knowledge.types import ContentType
-from agno.utils.log import log_debug, log_info, logger
+from agno.utils.log import log_info, logger
 
 try:
     from agno.aws.resource.s3.object import S3Object  # type: ignore
@@ -37,11 +38,11 @@ class S3Reader(Reader):
     def get_supported_chunking_strategies(self) -> List[ChunkingStrategyType]:
         """Get the list of supported chunking strategies for S3 readers."""
         return [
-            ChunkingStrategyType.FIXED_SIZE_CHUNKING,
-            ChunkingStrategyType.AGENTIC_CHUNKING,
-            ChunkingStrategyType.DOCUMENT_CHUNKING,
-            ChunkingStrategyType.RECURSIVE_CHUNKING,
-            ChunkingStrategyType.SEMANTIC_CHUNKING,
+            ChunkingStrategyType.FIXED_SIZE_CHUNKER,
+            ChunkingStrategyType.AGENTIC_CHUNKER,
+            ChunkingStrategyType.DOCUMENT_CHUNKER,
+            ChunkingStrategyType.RECURSIVE_CHUNKER,
+            ChunkingStrategyType.SEMANTIC_CHUNKER,
         ]
 
     @classmethod
@@ -52,120 +53,49 @@ class S3Reader(Reader):
         try:
             log_info(f"Reading S3 file: {s3_object.uri}")
 
+            # Read PDF files
             if s3_object.uri.endswith(".pdf"):
-                return S3PDFReader().read(name, s3_object)
+                object_resource = s3_object.get_resource()
+                object_body = object_resource.get()["Body"]
+                doc_name = (
+                    s3_object.name.split("/")[-1].split(".")[0].replace("/", "_").replace(" ", "_")
+                    if name is None
+                    else name
+                )
+                return PDFReader().read(pdf=BytesIO(object_body.read()), name=doc_name)
+
+            # Read text files
             else:
-                return S3TextReader().read(name, s3_object)
+                doc_name = (
+                    s3_object.name.split("/")[-1].split(".")[0].replace("/", "_").replace(" ", "_")
+                    if name is None
+                    else name
+                )
+                obj_name = s3_object.name.split("/")[-1]
+                temporary_file = Path("storage").joinpath(obj_name)
+                s3_object.download(temporary_file)
+
+                # TODO: Before we were using textract here. Needed?
+                # s3_object.download(temporary_file)
+                # doc_content = textract.process(temporary_file)
+                # documents = [
+                #     Document(
+                #         name=doc_name,
+                #         id=doc_name,
+                #         content=doc_content.decode("utf-8"),
+                #     )
+                # ]
+
+                documents = TextReader().read(file=temporary_file, name=doc_name)
+
+                temporary_file.unlink()
+                return documents
 
         except Exception as e:
             logger.error(f"Error reading: {s3_object.uri}: {e}")
-        return []
-
-    async def async_read(self, name: Optional[str], s3_object: S3Object) -> List[Document]:
-        """Asynchronously read S3 files by running the synchronous read operation in a thread."""
-        return await asyncio.to_thread(self.read, name, s3_object)
-
-
-class S3TextReader(Reader):
-    """Reader for text files on S3"""
 
-    def get_supported_chunking_strategies(self) -> List[ChunkingStrategyType]:
-        """Get the list of supported chunking strategies for S3 text readers."""
-        return [
-            ChunkingStrategyType.AGENTIC_CHUNKING,
-            ChunkingStrategyType.DOCUMENT_CHUNKING,
-            ChunkingStrategyType.RECURSIVE_CHUNKING,
-        ]
-
-    def get_supported_content_types(self) -> List[ContentType]:
-        return [ContentType.TEXT]
-
-    def read(self, name: Optional[str], s3_object: S3Object) -> List[Document]:
-        try:
-            log_info(f"Reading text file: {s3_object.uri}")
-
-            doc_name = s3_object.name.split("/")[-1].split(".")[0].replace("/", "_").replace(" ", "_")
-            if name is not None:
-                doc_name = name
-            obj_name = s3_object.name.split("/")[-1]
-            temporary_file = Path("storage").joinpath(obj_name)
-            s3_object.download(temporary_file)
-
-            log_info(f"Parsing: {temporary_file}")
-            doc_content = textract.process(temporary_file)
-            documents = [
-                Document(
-                    name=doc_name,
-                    id=doc_name,
-                    content=doc_content.decode("utf-8"),
-                )
-            ]
-            if self.chunk:
-                chunked_documents = []
-                for document in documents:
-                    chunked_documents.extend(self.chunk_document(document))
-                return chunked_documents
-
-            log_debug(f"Deleting: {temporary_file}")
-            temporary_file.unlink()
-            return documents
-        except Exception as e:
-            logger.error(f"Error reading: {s3_object.uri}: {e}")
         return []
 
     async def async_read(self, name: Optional[str], s3_object: S3Object) -> List[Document]:
-        """Asynchronously read text files from S3 by running the synchronous read operation in a thread.
-
-        Args:
-            s3_object (S3Object): The S3 object to read
-
-        Returns:
-            List[Document]: List of documents from the text file
-        """
-        return await asyncio.to_thread(self.read, name, s3_object)
-
-
-class S3PDFReader(Reader):
-    """Reader for PDF files on S3"""
-
-    def get_supported_content_types(self) -> List[ContentType]:
-        return [ContentType.FILE]
-
-    def read(self, name: Optional[str], s3_object: S3Object) -> List[Document]:
-        try:
-            log_info(f"Reading PDF file: {s3_object.uri}")
-
-            object_resource = s3_object.get_resource()
-            object_body = object_resource.get()["Body"]
-            doc_name = s3_object.name.split("/")[-1].split(".")[0].replace("/", "_").replace(" ", "_")
-            if name is not None:
-                doc_name = name
-            doc_reader = DocumentReader(BytesIO(object_body.read()))
-            documents = [
-                Document(
-                    name=doc_name,
-                    id=str(uuid4()),
-                    meta_data={"page": page_number},
-                    content=page.extract_text(),
-                )
-                for page_number, page in enumerate(doc_reader.pages, start=1)
-            ]
-            if self.chunk:
-                chunked_documents = []
-                for document in documents:
-                    chunked_documents.extend(self.chunk_document(document))
-                return chunked_documents
-            return documents
-        except Exception:
-            raise
-
-    async def async_read(self, name: Optional[str], s3_object: S3Object) -> List[Document]:
-        """Asynchronously read PDF files from S3 by running the synchronous read operation in a thread.
-
-        Args:
-            s3_object (S3Object): The S3 object to read
-
-        Returns:
-            List[Document]: List of documents from the PDF file
-        """
+        """Asynchronously read S3 files by running the synchronous read operation in a thread."""
         return await asyncio.to_thread(self.read, name, s3_object)

agno/knowledge/reader/text_reader.py

@@ -21,11 +21,11 @@ class TextReader(Reader):
     def get_supported_chunking_strategies(self) -> List[ChunkingStrategyType]:
         """Get the list of supported chunking strategies for Text readers."""
         return [
-            ChunkingStrategyType.FIXED_SIZE_CHUNKING,
-            ChunkingStrategyType.AGENTIC_CHUNKING,
-            ChunkingStrategyType.DOCUMENT_CHUNKING,
-            ChunkingStrategyType.RECURSIVE_CHUNKING,
-            ChunkingStrategyType.SEMANTIC_CHUNKING,
+            ChunkingStrategyType.FIXED_SIZE_CHUNKER,
+            ChunkingStrategyType.AGENTIC_CHUNKER,
+            ChunkingStrategyType.DOCUMENT_CHUNKER,
+            ChunkingStrategyType.RECURSIVE_CHUNKER,
+            ChunkingStrategyType.SEMANTIC_CHUNKER,
         ]
 
     @classmethod

agno/knowledge/reader/url_reader.py

@@ -1,3 +1,6 @@
+from io import BytesIO
+from os.path import basename
+from pathlib import Path
 from typing import List, Optional
 from urllib.parse import urlparse
 
@@ -7,6 +10,8 @@ from agno.knowledge.chunking.fixed import FixedSizeChunking
 from agno.knowledge.chunking.strategy import ChunkingStrategy, ChunkingStrategyType
 from agno.knowledge.document.base import Document
 from agno.knowledge.reader.base import Reader
+from agno.knowledge.reader.csv_reader import CSVReader
+from agno.knowledge.reader.pdf_reader import PDFReader
 from agno.knowledge.types import ContentType
 from agno.utils.http import async_fetch_with_retry, fetch_with_retry
 from agno.utils.log import log_debug
@@ -25,31 +30,43 @@ class URLReader(Reader):
     def get_supported_chunking_strategies(self) -> List[ChunkingStrategyType]:
         """Get the list of supported chunking strategies for URL readers."""
         return [
-            ChunkingStrategyType.FIXED_SIZE_CHUNKING,
-            ChunkingStrategyType.AGENTIC_CHUNKING,
-            ChunkingStrategyType.DOCUMENT_CHUNKING,
-            ChunkingStrategyType.RECURSIVE_CHUNKING,
-            ChunkingStrategyType.SEMANTIC_CHUNKING,
+            ChunkingStrategyType.FIXED_SIZE_CHUNKER,
+            ChunkingStrategyType.AGENTIC_CHUNKER,
+            ChunkingStrategyType.DOCUMENT_CHUNKER,
+            ChunkingStrategyType.RECURSIVE_CHUNKER,
+            ChunkingStrategyType.SEMANTIC_CHUNKER,
         ]
 
     @classmethod
     def get_supported_content_types(self) -> List[ContentType]:
         return [ContentType.URL]
 
-    def read(self, url: str, id: Optional[str] = None, name: Optional[str] = None) -> List[Document]:
+    def read(
+        self, url: str, id: Optional[str] = None, name: Optional[str] = None, password: Optional[str] = None
+    ) -> List[Document]:
         if not url:
             raise ValueError("No url provided")
 
         log_debug(f"Reading: {url}")
+
         # Retry the request up to 3 times with exponential backoff
         response = fetch_with_retry(url, proxy=self.proxy)
 
-        document = self._create_document(url, response.text, id, name)
-        if self.chunk:
-            return self.chunk_document(document)
-        return [document]
+        documents = self._create_documents(
+            url=url, text=response.text, content=response.content, id=id, name=name, password=password
+        )
+
+        if not self.chunk:
+            return documents
+
+        chunked_documents = []
+        for document in documents:
+            chunked_documents.append(self.chunk_document(document))
+        return [doc for sublist in chunked_documents for doc in sublist]
 
-    async def async_read(self, url: str, id: Optional[str] = None, name: Optional[str] = None) -> List[Document]:
+    async def async_read(
+        self, url: str, id: Optional[str] = None, name: Optional[str] = None, password: Optional[str] = None
+    ) -> List[Document]:
         """Async version of read method"""
         if not url:
             raise ValueError("No url provided")
@@ -59,26 +76,53 @@ class URLReader(Reader):
         async with httpx.AsyncClient(**client_args) as client:  # type: ignore
             response = await async_fetch_with_retry(url, client=client)
 
-        document = self._create_document(url, response.text, id, name)
-        if self.chunk:
-            return await self.chunk_documents_async([document])
-        return [document]
+        documents = self._create_documents(
+            url=url, text=response.text, content=response.content, id=id, name=name, password=password
+        )
+
+        if not self.chunk:
+            return documents
+
+        return await self.chunk_documents_async(documents)
 
-    def _create_document(
-        self, url: str, content: str, id: Optional[str] = None, name: Optional[str] = None
-    ) -> Document:
+    def _create_documents(
+        self,
+        url: str,
+        text: str,
+        content: bytes,
+        id: Optional[str] = None,
+        name: Optional[str] = None,
+        password: Optional[str] = None,
+    ) -> List[Document]:
         """Helper method to create a document from URL content"""
+
+        # Determine file extension from URL
         parsed_url = urlparse(url)
-        doc_name = name or parsed_url.path.strip("/").replace("/", "_").replace(" ", "_")
-        if not doc_name:
-            doc_name = parsed_url.netloc
-        if not doc_name:
-            doc_name = url
-
-        return Document(
-            name=doc_name,
-            id=id or doc_name,
-            meta_data={"url": url},
-            content=content,
-            size=len(content),
-        )
+        url_path = Path(parsed_url.path)  # type: ignore
+        file_extension = url_path.suffix.lower()
+
+        # Read the document using the appropriate reader
+        if file_extension == ".csv":
+            filename = basename(parsed_url.path) or "data.csv"
+            return CSVReader().read(file=BytesIO(content), name=filename)
+        elif file_extension == ".pdf":
+            if password:
+                return PDFReader().read(pdf=BytesIO(content), name=name, password=password)
+            else:
+                return PDFReader().read(pdf=BytesIO(content), name=name)
+        else:
+            doc_name = name or parsed_url.path.strip("/").replace("/", "_").replace(" ", "_")
+            if not doc_name:
+                doc_name = parsed_url.netloc
+            if not doc_name:
+                doc_name = url
+
+        return [
+            Document(
+                name=doc_name,
+                id=id or doc_name,
+                meta_data={"url": url},
+                content=text,
+                size=len(text),
+            )
+        ]

agno/knowledge/reader/web_search_reader.py

@@ -11,7 +11,6 @@ from agno.knowledge.chunking.semantic import SemanticChunking
 from agno.knowledge.chunking.strategy import ChunkingStrategy, ChunkingStrategyType
 from agno.knowledge.document.base import Document
 from agno.knowledge.reader.base import Reader
-from agno.knowledge.reader.url_reader import URLReader
 from agno.knowledge.types import ContentType
 from agno.utils.log import log_debug, logger
 
@@ -48,30 +47,25 @@ class WebSearchReader(Reader):
 
     # Internal state
     _visited_urls: Set[str] = field(default_factory=set)
-    _url_reader: Optional[URLReader] = None
     _last_search_time: float = field(default=0.0, init=False)
 
     # Override default chunking strategy
     chunking_strategy: Optional[ChunkingStrategy] = SemanticChunking()
 
-    def __post_init__(self):
-        """Initialize the URL reader and chunking strategy after dataclass initialization"""
-        self._url_reader = URLReader()
-
     @classmethod
     def get_supported_chunking_strategies(self) -> List[ChunkingStrategyType]:
         """Get the list of supported chunking strategies for Web Search readers."""
         return [
-            ChunkingStrategyType.AGENTIC_CHUNKING,
-            ChunkingStrategyType.DOCUMENT_CHUNKING,
-            ChunkingStrategyType.RECURSIVE_CHUNKING,
-            ChunkingStrategyType.SEMANTIC_CHUNKING,
-            ChunkingStrategyType.FIXED_SIZE_CHUNKING,
+            ChunkingStrategyType.AGENTIC_CHUNKER,
+            ChunkingStrategyType.DOCUMENT_CHUNKER,
+            ChunkingStrategyType.RECURSIVE_CHUNKER,
+            ChunkingStrategyType.SEMANTIC_CHUNKER,
+            ChunkingStrategyType.FIXED_SIZE_CHUNKER,
         ]
 
     @classmethod
     def get_supported_content_types(self) -> List[ContentType]:
-        return [ContentType.URL, ContentType.TEXT]
+        return [ContentType.TOPIC]
 
     def _respect_rate_limits(self):
         """Ensure we don't exceed rate limits"""
@@ -328,23 +322,6 @@ class WebSearchReader(Reader):
             self._visited_urls.add(url)
 
             try:
-                # Use the URL reader for async fetching
-                if self._url_reader:
-                    docs = await self._url_reader.async_read(url)
-                    if docs:
-                        # Use the first document and add search metadata
-                        doc = docs[0]
-                        doc.meta_data.update(
-                            {
-                                "search_title": result.get("title", ""),
-                                "search_description": result.get("description", ""),
-                                "source": "web_search",
-                                "search_engine": self.search_engine,
-                            }
-                        )
-                        return doc
-
-                # Fallback to manual async fetching
                 headers = {"User-Agent": self.user_agent}
                 async with httpx.AsyncClient(timeout=self.request_timeout) as client:
                     response = await client.get(url, headers=headers, follow_redirects=True)

agno/knowledge/reader/website_reader.py

@@ -52,11 +52,11 @@ class WebsiteReader(Reader):
     def get_supported_chunking_strategies(self) -> List[ChunkingStrategyType]:
         """Get the list of supported chunking strategies for Website readers."""
         return [
-            ChunkingStrategyType.AGENTIC_CHUNKING,
-            ChunkingStrategyType.DOCUMENT_CHUNKING,
-            ChunkingStrategyType.RECURSIVE_CHUNKING,
-            ChunkingStrategyType.SEMANTIC_CHUNKING,
-            ChunkingStrategyType.FIXED_SIZE_CHUNKING,
+            ChunkingStrategyType.AGENTIC_CHUNKER,
+            ChunkingStrategyType.DOCUMENT_CHUNKER,
+            ChunkingStrategyType.RECURSIVE_CHUNKER,
+            ChunkingStrategyType.SEMANTIC_CHUNKER,
+            ChunkingStrategyType.FIXED_SIZE_CHUNKER,
         ]
 
     @classmethod

agno/knowledge/reader/wikipedia_reader.py

@@ -26,11 +26,11 @@ class WikipediaReader(Reader):
     def get_supported_chunking_strategies(self) -> List[ChunkingStrategyType]:
         """Get the list of supported chunking strategies for Wikipedia readers."""
         return [
-            ChunkingStrategyType.FIXED_SIZE_CHUNKING,
-            ChunkingStrategyType.AGENTIC_CHUNKING,
-            ChunkingStrategyType.DOCUMENT_CHUNKING,
-            ChunkingStrategyType.RECURSIVE_CHUNKING,
-            ChunkingStrategyType.SEMANTIC_CHUNKING,
+            ChunkingStrategyType.FIXED_SIZE_CHUNKER,
+            ChunkingStrategyType.AGENTIC_CHUNKER,
+            ChunkingStrategyType.DOCUMENT_CHUNKER,
+            ChunkingStrategyType.RECURSIVE_CHUNKER,
+            ChunkingStrategyType.SEMANTIC_CHUNKER,
         ]
 
     @classmethod

agno/knowledge/reader/youtube_reader.py

@@ -26,16 +26,16 @@ class YouTubeReader(Reader):
     def get_supported_chunking_strategies(self) -> List[ChunkingStrategyType]:
         """Get the list of supported chunking strategies for YouTube readers."""
         return [
-            ChunkingStrategyType.RECURSIVE_CHUNKING,
-            ChunkingStrategyType.AGENTIC_CHUNKING,
-            ChunkingStrategyType.DOCUMENT_CHUNKING,
-            ChunkingStrategyType.SEMANTIC_CHUNKING,
-            ChunkingStrategyType.FIXED_SIZE_CHUNKING,
+            ChunkingStrategyType.RECURSIVE_CHUNKER,
+            ChunkingStrategyType.AGENTIC_CHUNKER,
+            ChunkingStrategyType.DOCUMENT_CHUNKER,
+            ChunkingStrategyType.SEMANTIC_CHUNKER,
+            ChunkingStrategyType.FIXED_SIZE_CHUNKER,
         ]
 
     @classmethod
     def get_supported_content_types(self) -> List[ContentType]:
-        return [ContentType.URL, ContentType.YOUTUBE]
+        return [ContentType.YOUTUBE]
 
     def read(self, url: str, name: Optional[str] = None) -> List[Document]:
         try:

agno/knowledge/utils.py

@@ -11,23 +11,23 @@ def _get_chunker_class(strategy_type):
 
     # Map strategy types to their corresponding classes
     strategy_class_mapping = {
-        ChunkingStrategyType.AGENTIC_CHUNKING: lambda: _import_class(
+        ChunkingStrategyType.AGENTIC_CHUNKER: lambda: _import_class(
             "agno.knowledge.chunking.agentic", "AgenticChunking"
         ),
-        ChunkingStrategyType.DOCUMENT_CHUNKING: lambda: _import_class(
+        ChunkingStrategyType.DOCUMENT_CHUNKER: lambda: _import_class(
             "agno.knowledge.chunking.document", "DocumentChunking"
         ),
-        ChunkingStrategyType.RECURSIVE_CHUNKING: lambda: _import_class(
+        ChunkingStrategyType.RECURSIVE_CHUNKER: lambda: _import_class(
             "agno.knowledge.chunking.recursive", "RecursiveChunking"
         ),
-        ChunkingStrategyType.SEMANTIC_CHUNKING: lambda: _import_class(
+        ChunkingStrategyType.SEMANTIC_CHUNKER: lambda: _import_class(
             "agno.knowledge.chunking.semantic", "SemanticChunking"
         ),
-        ChunkingStrategyType.FIXED_SIZE_CHUNKING: lambda: _import_class(
+        ChunkingStrategyType.FIXED_SIZE_CHUNKER: lambda: _import_class(
             "agno.knowledge.chunking.fixed", "FixedSizeChunking"
         ),
-        ChunkingStrategyType.ROW_CHUNKING: lambda: _import_class("agno.knowledge.chunking.row", "RowChunking"),
-        ChunkingStrategyType.MARKDOWN_CHUNKING: lambda: _import_class(
+        ChunkingStrategyType.ROW_CHUNKER: lambda: _import_class("agno.knowledge.chunking.row", "RowChunking"),
+        ChunkingStrategyType.MARKDOWN_CHUNKER: lambda: _import_class(
             "agno.knowledge.chunking.markdown", "MarkdownChunking"
         ),
     }
@@ -61,8 +61,8 @@ def get_reader_info(reader_key: str) -> Dict:
 
         return {
             "id": reader_key,
-            "name": reader_key.replace("_", " ").title() + " Reader",
-            "description": f"Reads {reader_key} files",
+            "name": "".join(word.capitalize() for word in reader_key.split("_")) + "Reader",
+            "description": reader_instance.description,
             "chunking_strategies": [
                 strategy.value for strategy in supported_strategies
             ],  # Convert enums to string values
@@ -132,7 +132,7 @@ def get_chunker_info(chunker_key: str) -> Dict:
             return {
                 "key": chunker_key,
                 "class_name": class_name,
-                "name": class_name.replace("Chunking", "").replace("Strategy", ""),
+                "name": chunker_key,
                 "description": docstring.strip(),
                 "strategy_type": strategy_type.value,
             }

agno/models/aws/bedrock.py

@@ -181,14 +181,10 @@ class AwsBedrock(Model):
                 required = []
 
                 for param_name, param_info in func_def.get("parameters", {}).get("properties", {}).items():
-                    param_type = param_info.get("type")
-                    if isinstance(param_type, list):
-                        param_type = [t for t in param_type if t != "null"][0]
+                    properties[param_name] = param_info.copy()
 
-                    properties[param_name] = {
-                        "type": param_type or "string",
-                        "description": param_info.get("description") or "",
-                    }
+                    if "description" not in properties[param_name]:
+                        properties[param_name]["description"] = ""
 
                     if "null" not in (
                         param_info.get("type") if isinstance(param_info.get("type"), list) else [param_info.get("type")]

agno/models/base.py

@@ -25,7 +25,7 @@ from agno.media import Audio, AudioArtifact, AudioResponse, Image, ImageArtifact
 from agno.models.message import Citations, Message
 from agno.models.metrics import Metrics
 from agno.models.response import ModelResponse, ModelResponseEvent, ToolExecution
-from agno.run.agent import RunContentEvent, RunOutput, RunOutputEvent
+from agno.run.agent import CustomEvent, RunContentEvent, RunOutput, RunOutputEvent
 from agno.run.team import RunContentEvent as TeamRunContentEvent
 from agno.run.team import TeamRunOutputEvent
 from agno.tools.function import Function, FunctionCall, FunctionExecutionResult, UserInputField
@@ -1223,6 +1223,9 @@ class Model(ABC):
                         if function_call.function.show_result:
                             yield ModelResponse(content=item.content)
 
+                        if isinstance(item, CustomEvent):
+                            function_call_output += str(item)
+
                     # Yield the event itself to bubble it up
                     yield item
 
@@ -1389,7 +1392,7 @@ class Model(ABC):
     async def arun_function_call(
         self,
         function_call: FunctionCall,
-    ) -> Tuple[Union[bool, AgentRunException], Timer, FunctionCall, Optional[Dict[str, Any]]]:
+    ) -> Tuple[Union[bool, AgentRunException], Timer, FunctionCall, FunctionExecutionResult]:
         """Run a single function call and return its success status, timer, and the FunctionCall object."""
         from inspect import isasyncgenfunction, iscoroutine, iscoroutinefunction
 
@@ -1423,7 +1426,7 @@ class Model(ABC):
             raise e
 
         function_call_timer.stop()
-        return success, function_call_timer, function_call, result.updated_session_state
+        return success, function_call_timer, function_call, result
 
     async def arun_function_calls(
         self,
@@ -1569,7 +1572,9 @@ class Model(ABC):
                 raise result
 
             # Unpack result
-            function_call_success, function_call_timer, function_call, updated_session_state = result
+            function_call_success, function_call_timer, function_call, function_execution_result = result
+
+            updated_session_state = function_execution_result.updated_session_state
 
             # Handle AgentRunException
             if isinstance(function_call_success, AgentRunException):
@@ -1623,20 +1628,43 @@ 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:
                             yield ModelResponse(content=str(item))
             else:
-                function_call_output = str(function_call.result)
+                from agno.tools.function import ToolResult
+
+                if isinstance(function_execution_result.result, ToolResult):
+                    tool_result = function_execution_result.result
+                    function_call_output = tool_result.content
+
+                    if tool_result.images:
+                        function_execution_result.images = tool_result.images
+                    if tool_result.videos:
+                        function_execution_result.videos = tool_result.videos
+                    if tool_result.audios:
+                        function_execution_result.audios = tool_result.audios
+                else:
+                    function_call_output = str(function_call.result)
+
                 if function_call.function.show_result:
                     yield ModelResponse(content=function_call_output)
 
             # Create and yield function call result
             function_call_result = self.create_function_call_result(
-                function_call, success=function_call_success, output=function_call_output, timer=function_call_timer
+                function_call,
+                success=function_call_success,
+                output=function_call_output,
+                timer=function_call_timer,
+                function_execution_result=function_execution_result,
             )
             yield ModelResponse(
                 content=f"{function_call.get_call_str()} completed in {function_call_timer.elapsed:.4f}s.",
@@ -1653,6 +1681,9 @@ class Model(ABC):
                 ],
                 event=ModelResponseEvent.tool_call_completed.value,
                 updated_session_state=updated_session_state,
+                images=function_execution_result.images,
+                videos=function_execution_result.videos,
+                audios=function_execution_result.audios,
             )
 
             # Add function call result to function call results