agno 2.3.15__py3-none-any.whl → 2.3.17__py3-none-any.whl

agno/knowledge/reader/pptx_reader.py

@@ -47,11 +47,9 @@ class PPTXReader(Reader):
                 presentation = Presentation(str(file))
                 doc_name = name or file.stem
             else:
-                log_debug(f"Reading uploaded file: {getattr(file, 'name', 'pptx_file')}")
+                log_debug(f"Reading uploaded file: {getattr(file, 'name', 'BytesIO')}")
                 presentation = Presentation(file)
-                doc_name = name or (
-                    getattr(file, "name", "pptx_file").split(".")[0] if hasattr(file, "name") else "pptx_file"
-                )
+                doc_name = name or getattr(file, "name", "pptx_file").split(".")[0]
 
             # Extract text from all slides
             slide_texts = []

agno/knowledge/reader/s3_reader.py

@@ -53,29 +53,20 @@ class S3Reader(Reader):
         try:
             log_debug(f"Reading S3 file: {s3_object.uri}")
 
+            doc_name = name or s3_object.name.split("/")[-1].split(".")[0].replace("/", "_").replace(" ", "_")
+
             # Read PDF files
             if s3_object.uri.endswith(".pdf"):
                 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:
-                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)
                 documents = TextReader().read(file=temporary_file, name=doc_name)
-
                 temporary_file.unlink()
                 return documents
 

agno/knowledge/reader/text_reader.py

@@ -39,16 +39,10 @@ class TextReader(Reader):
                     raise FileNotFoundError(f"Could not find file: {file}")
                 log_debug(f"Reading: {file}")
                 file_name = name or file.stem
-                file_contents = file.read_text(self.encoding or "utf-8")
+                file_contents = file.read_text(encoding=self.encoding or "utf-8")
             else:
-                # Handle BytesIO and other file-like objects that may not have a name attribute
-                if name:
-                    file_name = name
-                elif hasattr(file, "name") and file.name is not None:
-                    file_name = file.name.split(".")[0]
-                else:
-                    file_name = "text_file"
-                log_debug(f"Reading uploaded file: {file_name}")
+                log_debug(f"Reading uploaded file: {getattr(file, 'name', 'BytesIO')}")
+                file_name = name or getattr(file, "name", "text_file").split(".")[0]
                 file.seek(0)
                 file_contents = file.read().decode(self.encoding or "utf-8")
 
@@ -85,16 +79,10 @@ class TextReader(Reader):
                         file_contents = await f.read()
                 except ImportError:
                     log_warning("aiofiles not installed, using synchronous file I/O")
-                    file_contents = file.read_text(self.encoding or "utf-8")
+                    file_contents = file.read_text(encoding=self.encoding or "utf-8")
             else:
-                # Handle BytesIO and other file-like objects that may not have a name attribute
-                if name:
-                    file_name = name
-                elif hasattr(file, "name") and file.name is not None:
-                    file_name = file.name.split(".")[0]
-                else:
-                    file_name = "text_file"
-                log_debug(f"Reading uploaded file asynchronously: {file_name}")
+                log_debug(f"Reading uploaded file asynchronously: {getattr(file, 'name', 'BytesIO')}")
+                file_name = name or getattr(file, "name", "text_file").split(".")[0]
                 file.seek(0)
                 file_contents = file.read().decode(self.encoding or "utf-8")
 

agno/knowledge/reader/web_search_reader.py

@@ -263,21 +263,17 @@ class WebSearchReader(Reader):
 
         log_debug(f"Starting async web search reader for query: {query}")
 
-        # Perform web search (synchronous operation)
         search_results = self._perform_web_search(query)
         if not search_results:
             logger.warning(f"No search results found for query: {query}")
             return []
 
-        # Create tasks for fetching content from each URL
         async def fetch_url_async(result: Dict[str, str]) -> Optional[Document]:
             url = result.get("url", "")
 
-            # Skip if URL is invalid or already visited
             if not self._is_valid_url(url):
                 return None
 
-            # Mark URL as visited
             self._visited_urls.add(url)
 
             try:
@@ -292,32 +288,25 @@ class WebSearchReader(Reader):
                     else:
                         content = response.text
 
-                    document = self._create_document_from_url(url, content, result)
-                    return document
+                    return self._create_document_from_url(url, content, result)
 
             except Exception as e:
                 logger.warning(f"Error fetching {url}: {e}")
                 return None
 
-        # Create tasks for all URLs
-        tasks = [fetch_url_async(result) for result in search_results]
-
-        # Execute all tasks concurrently with delays
         documents = []
-        for i, task in enumerate(tasks):
-            if i > 0:  # Add delay between requests (except for the first one)
+        for i, result in enumerate(search_results):
+            if i > 0:
                 await asyncio.sleep(self.delay_between_requests)
 
-            doc = await task
+            doc = await fetch_url_async(result)
             if doc is not None:
-                # Apply chunking if enabled
                 if self.chunk:
                     chunked_docs = await self.chunk_documents_async([doc])
                     documents.extend(chunked_docs)
                 else:
                     documents.append(doc)
 
-                # Stop if we've reached max_results
                 if len(documents) >= self.max_results:
                     break
 

agno/os/app.py

@@ -5,13 +5,15 @@ from typing import Any, Dict, List, Literal, Optional, Union
 from uuid import uuid4
 
 from fastapi import APIRouter, FastAPI, HTTPException
+from fastapi.exceptions import RequestValidationError
 from fastapi.responses import JSONResponse
 from fastapi.routing import APIRoute
+from httpx import HTTPStatusError
 from rich import box
 from rich.panel import Panel
 from starlette.requests import Request
 
-from agno.agent.agent import Agent
+from agno.agent import Agent, RemoteAgent
 from agno.db.base import AsyncBaseDb, BaseDb
 from agno.knowledge.knowledge import Knowledge
 from agno.os.config import (
@@ -32,7 +34,7 @@ from agno.os.config import (
     TracesDomainConfig,
 )
 from agno.os.interfaces.base import BaseInterface
-from agno.os.router import get_base_router
+from agno.os.router import get_base_router, get_websocket_router
 from agno.os.routers.agents import get_agent_router
 from agno.os.routers.database import get_database_router
 from agno.os.routers.evals import get_eval_router
@@ -44,7 +46,7 @@ from agno.os.routers.metrics import get_metrics_router
 from agno.os.routers.session import get_session_router
 from agno.os.routers.teams import get_team_router
 from agno.os.routers.traces import get_traces_router
-from agno.os.routers.workflows import get_websocket_router, get_workflow_router
+from agno.os.routers.workflows import get_workflow_router
 from agno.os.settings import AgnoAPISettings
 from agno.os.utils import (
     collect_mcp_tools_from_team,
@@ -55,34 +57,46 @@ from agno.os.utils import (
     setup_tracing_for_os,
     update_cors_middleware,
 )
-from agno.team.team import Team
+from agno.remote.base import RemoteDb, RemoteKnowledge
+from agno.team import RemoteTeam, Team
 from agno.utils.log import log_debug, log_error, log_info, log_warning
 from agno.utils.string import generate_id, generate_id_from_name
-from agno.workflow.workflow import Workflow
+from agno.workflow import RemoteWorkflow, Workflow
 
 
 @asynccontextmanager
 async def mcp_lifespan(_, mcp_tools):
     """Manage MCP connection lifecycle inside a FastAPI app"""
-    # Startup logic: connect to all contextual MCP servers
     for tool in mcp_tools:
         await tool.connect()
 
     yield
 
-    # Shutdown logic: Close all contextual MCP connections
     for tool in mcp_tools:
         await tool.close()
 
 
+@asynccontextmanager
+async def http_client_lifespan(_):
+    """Manage httpx client lifecycle for proper connection pool cleanup."""
+    from agno.utils.http import aclose_default_clients
+
+    yield
+
+    await aclose_default_clients()
+
+
 @asynccontextmanager
 async def db_lifespan(app: FastAPI, agent_os: "AgentOS"):
-    """Initializes databases in the event loop"""
+    """Initializes databases in the event loop and closes them on shutdown."""
     if agent_os.auto_provision_dbs:
         agent_os._initialize_sync_databases()
         await agent_os._initialize_async_databases()
+
     yield
 
+    await agent_os._close_databases()
+
 
 def _combine_app_lifespans(lifespans: list) -> Any:
     """Combine multiple FastAPI app lifespan context managers into one."""
@@ -115,9 +129,9 @@ class AgentOS:
         name: Optional[str] = None,
         description: Optional[str] = None,
         version: Optional[str] = None,
-        agents: Optional[List[Agent]] = None,
-        teams: Optional[List[Team]] = None,
-        workflows: Optional[List[Workflow]] = None,
+        agents: Optional[List[Union[Agent, RemoteAgent]]] = None,
+        teams: Optional[List[Union[Team, RemoteTeam]]] = None,
+        workflows: Optional[List[Union[Workflow, RemoteWorkflow]]] = None,
         knowledge: Optional[List[Knowledge]] = None,
         interfaces: Optional[List[BaseInterface]] = None,
         a2a_interface: bool = False,
@@ -171,9 +185,9 @@ class AgentOS:
 
         self.config = load_yaml_config(config) if isinstance(config, str) else config
 
-        self.agents: Optional[List[Agent]] = agents
-        self.workflows: Optional[List[Workflow]] = workflows
-        self.teams: Optional[List[Team]] = teams
+        self.agents: Optional[List[Union[Agent, RemoteAgent]]] = agents
+        self.workflows: Optional[List[Union[Workflow, RemoteWorkflow]]] = workflows
+        self.teams: Optional[List[Union[Team, RemoteTeam]]] = teams
         self.interfaces = interfaces or []
         self.a2a_interface = a2a_interface
         self.knowledge = knowledge
@@ -400,6 +414,8 @@ class AgentOS:
         if not self.agents:
             return
         for agent in self.agents:
+            if isinstance(agent, RemoteAgent):
+                continue
             # Track all MCP tools to later handle their connection
             if agent.tools:
                 for tool in agent.tools:
@@ -424,6 +440,8 @@ class AgentOS:
             return
 
         for team in self.teams:
+            if isinstance(team, RemoteTeam):
+                continue
             # Track all MCP tools recursively
             collect_mcp_tools_from_team(team, self.mcp_tools)
 
@@ -449,6 +467,8 @@ class AgentOS:
 
         if self.workflows:
             for workflow in self.workflows:
+                if isinstance(workflow, RemoteWorkflow):
+                    continue
                 # Track MCP tools recursively in workflow members
                 collect_mcp_tools_from_workflow(workflow, self.mcp_tools)
 
@@ -473,7 +493,7 @@ class AgentOS:
             return
 
         # Fall back to finding the first available database
-        db: Optional[Union[BaseDb, AsyncBaseDb]] = None
+        db: Optional[Union[BaseDb, AsyncBaseDb, RemoteDb]] = None
 
         for agent in self.agents or []:
             if agent.db:
@@ -535,6 +555,9 @@ class AgentOS:
             # The async database lifespan
             lifespans.append(partial(db_lifespan, agent_os=self))
 
+            # The httpx client cleanup lifespan (should be last to close after other lifespans)
+            lifespans.append(http_client_lifespan)
+
             # Combine lifespans and set them in the app
             if lifespans:
                 fastapi_app.router.lifespan_context = _combine_app_lifespans(lifespans)
@@ -560,6 +583,9 @@ class AgentOS:
             # Async database initialization lifespan
             lifespans.append(partial(db_lifespan, agent_os=self))  # type: ignore
 
+            # The httpx client cleanup lifespan (should be last to close after other lifespans)
+            lifespans.append(http_client_lifespan)
+
             final_lifespan = _combine_app_lifespans(lifespans) if lifespans else None
             fastapi_app = self._make_app(lifespan=final_lifespan)
 
@@ -587,6 +613,14 @@ class AgentOS:
 
         if not self._app_set:
 
+            @fastapi_app.exception_handler(RequestValidationError)
+            async def validation_exception_handler(_: Request, exc: RequestValidationError) -> JSONResponse:
+                log_error(f"Validation error (422): {exc.errors()}")
+                return JSONResponse(
+                    status_code=422,
+                    content={"detail": exc.errors()},
+                )
+
             @fastapi_app.exception_handler(HTTPException)
             async def http_exception_handler(_, exc: HTTPException) -> JSONResponse:
                 log_error(f"HTTP exception: {exc.status_code} {exc.detail}")
@@ -595,6 +629,16 @@ class AgentOS:
                     content={"detail": str(exc.detail)},
                 )
 
+            @fastapi_app.exception_handler(HTTPStatusError)
+            async def http_status_error_handler(_: Request, exc: HTTPStatusError) -> JSONResponse:
+                status_code = exc.response.status_code
+                detail = exc.response.text
+                log_error(f"Downstream server returned HTTP status error: {status_code} {detail}")
+                return JSONResponse(
+                    status_code=status_code,
+                    content={"detail": detail},
+                )
+
             @fastapi_app.exception_handler(Exception)
             async def general_exception_handler(_: Request, exc: Exception) -> JSONResponse:
                 import traceback
@@ -734,19 +778,28 @@ class AgentOS:
 
     def _get_telemetry_data(self) -> Dict[str, Any]:
         """Get the telemetry data for the OS"""
+        agent_ids = []
+        team_ids = []
+        workflow_ids = []
+        for agent in self.agents or []:
+            agent_ids.append(agent.id)
+        for team in self.teams or []:
+            team_ids.append(team.id)
+        for workflow in self.workflows or []:
+            workflow_ids.append(workflow.id)
         return {
-            "agents": [agent.id for agent in self.agents] if self.agents else None,
-            "teams": [team.id for team in self.teams] if self.teams else None,
-            "workflows": [workflow.id for workflow in self.workflows] if self.workflows else None,
+            "agents": agent_ids,
+            "teams": team_ids,
+            "workflows": workflow_ids,
             "interfaces": [interface.type for interface in self.interfaces] if self.interfaces else None,
         }
 
     def _auto_discover_databases(self) -> None:
         """Auto-discover and initialize the databases used by all contextual agents, teams and workflows."""
 
-        dbs: Dict[str, List[Union[BaseDb, AsyncBaseDb]]] = {}
+        dbs: Dict[str, List[Union[BaseDb, AsyncBaseDb, RemoteDb]]] = {}
         knowledge_dbs: Dict[
-            str, List[Union[BaseDb, AsyncBaseDb]]
+            str, List[Union[BaseDb, AsyncBaseDb, RemoteDb]]
         ] = {}  # Track databases specifically used for knowledge
 
         for agent in self.agents or []:
@@ -833,6 +886,32 @@ class AgentOS:
             except Exception as e:
                 log_warning(f"Failed to initialize async {db.__class__.__name__} (id: {db.id}): {e}")
 
+    async def _close_databases(self) -> None:
+        """Close all database connections and release connection pools."""
+        from itertools import chain
+
+        if not hasattr(self, "dbs") or not hasattr(self, "knowledge_dbs"):
+            return
+
+        unique_dbs = list(
+            {
+                id(db): db
+                for db in chain(
+                    chain.from_iterable(self.dbs.values()), chain.from_iterable(self.knowledge_dbs.values())
+                )
+            }.values()
+        )
+
+        for db in unique_dbs:
+            try:
+                if hasattr(db, "close") and callable(db.close):
+                    if isinstance(db, AsyncBaseDb):
+                        await db.close()
+                    else:
+                        db.close()
+            except Exception as e:
+                log_warning(f"Failed to close {db.__class__.__name__} (id: {db.id}): {e}")
+
     def _get_db_table_names(self, db: BaseDb) -> Dict[str, str]:
         """Get the table names for a database"""
         table_names = {
@@ -846,7 +925,9 @@ class AgentOS:
         return {k: v for k, v in table_names.items() if v is not None}
 
     def _register_db_with_validation(
-        self, registered_dbs: Dict[str, List[Union[BaseDb, AsyncBaseDb]]], db: Union[BaseDb, AsyncBaseDb]
+        self,
+        registered_dbs: Dict[str, List[Union[BaseDb, AsyncBaseDb, RemoteDb]]],
+        db: Union[BaseDb, AsyncBaseDb, RemoteDb],
     ) -> None:
         """Register a database in the contextual OS after validating it is not conflicting with registered databases"""
         if db.id in registered_dbs:
@@ -857,9 +938,9 @@ class AgentOS:
     def _auto_discover_knowledge_instances(self) -> None:
         """Auto-discover the knowledge instances used by all contextual agents, teams and workflows."""
         seen_ids = set()
-        knowledge_instances: List[Knowledge] = []
+        knowledge_instances: List[Union[Knowledge, RemoteKnowledge]] = []
 
-        def _add_knowledge_if_not_duplicate(knowledge: "Knowledge") -> None:
+        def _add_knowledge_if_not_duplicate(knowledge: Union["Knowledge", RemoteKnowledge]) -> None:
             """Add knowledge instance if it's not already in the list (by object identity or db_id)."""
             # Use database ID if available, otherwise use object ID as fallback
             if not knowledge.contents_db:

agno/os/auth.py

@@ -1,5 +1,5 @@
 from os import getenv
-from typing import List, Set
+from typing import List, Optional, Set
 
 from fastapi import Depends, HTTPException, Request
 from fastapi.security import HTTPAuthorizationCredentials, HTTPBearer
@@ -11,6 +11,30 @@ from agno.os.settings import AgnoAPISettings
 security = HTTPBearer(auto_error=False)
 
 
+def get_auth_token_from_request(request: Request) -> Optional[str]:
+    """
+    Extract the JWT/Bearer token from the Authorization header.
+
+    This is used to forward the auth token to remote agents/teams/workflows
+    when making requests through the gateway.
+
+    Args:
+        request: The FastAPI request object
+
+    Returns:
+        The bearer token string if present, None otherwise
+
+    Usage:
+        auth_token = get_auth_token_from_request(request)
+        if auth_token and isinstance(agent, RemoteAgent):
+            await agent.arun(message, auth_token=auth_token)
+    """
+    auth_header = request.headers.get("Authorization")
+    if auth_header and auth_header.lower().startswith("bearer "):
+        return auth_header[7:]  # Remove "Bearer " prefix
+    return None
+
+
 def _is_jwt_configured() -> bool:
     """Check if JWT authentication is configured via environment variables.
 

agno/os/interfaces/a2a/a2a.py

@@ -1,15 +1,16 @@
 """Main class for the A2A app, used to expose an Agno Agent, Team, or Workflow in an A2A compatible format."""
 
-from typing import Optional
+from typing import Optional, Union
 
 from fastapi.routing import APIRouter
 from typing_extensions import List
 
 from agno.agent import Agent
+from agno.agent.remote import RemoteAgent
 from agno.os.interfaces.a2a.router import attach_routes
 from agno.os.interfaces.base import BaseInterface
-from agno.team import Team
-from agno.workflow import Workflow
+from agno.team import RemoteTeam, Team
+from agno.workflow import RemoteWorkflow, Workflow
 
 
 class A2A(BaseInterface):
@@ -19,9 +20,9 @@ class A2A(BaseInterface):
 
     def __init__(
         self,
-        agents: Optional[List[Agent]] = None,
-        teams: Optional[List[Team]] = None,
-        workflows: Optional[List[Workflow]] = None,
+        agents: Optional[List[Union[Agent, RemoteAgent]]] = None,
+        teams: Optional[List[Union[Team, RemoteTeam]]] = None,
+        workflows: Optional[List[Union[Workflow, RemoteWorkflow]]] = None,
         prefix: str = "/a2a",
         tags: Optional[List[str]] = None,
     ):

agno/os/interfaces/a2a/router.py

@@ -23,22 +23,22 @@ except ImportError as e:
 
 import warnings
 
-from agno.agent import Agent
+from agno.agent import Agent, RemoteAgent
 from agno.os.interfaces.a2a.utils import (
     map_a2a_request_to_run_input,
     map_run_output_to_a2a_task,
     stream_a2a_response_with_error_handling,
 )
 from agno.os.utils import get_agent_by_id, get_request_kwargs, get_team_by_id, get_workflow_by_id
-from agno.team import Team
-from agno.workflow import Workflow
+from agno.team import RemoteTeam, Team
+from agno.workflow import RemoteWorkflow, Workflow
 
 
 def attach_routes(
     router: APIRouter,
-    agents: Optional[List[Agent]] = None,
-    teams: Optional[List[Team]] = None,
-    workflows: Optional[List[Workflow]] = None,
+    agents: Optional[List[Union[Agent, RemoteAgent]]] = None,
+    teams: Optional[List[Union[Team, RemoteTeam]]] = None,
+    workflows: Optional[List[Union[Workflow, RemoteWorkflow]]] = None,
 ) -> APIRouter:
     if agents is None and teams is None and workflows is None:
         raise ValueError("Agents, Teams, or Workflows are required to setup the A2A interface.")
@@ -687,7 +687,7 @@ def attach_routes(
                 status_code=400,
                 detail="Entity ID required. Provide it via 'agentId' in params.message or 'X-Agent-ID' header.",
             )
-        entity: Optional[Union[Agent, Team, Workflow]] = None
+        entity: Optional[Union[Agent, RemoteAgent, Team, RemoteTeam, Workflow, RemoteWorkflow]] = None
         if agents:
             entity = get_agent_by_id(agent_id, agents)
         if not entity and teams:
@@ -720,10 +720,10 @@ def attach_routes(
             else:
                 response = entity.arun(
                     input=run_input.input_content,
-                    images=run_input.images,
-                    videos=run_input.videos,
-                    audio=run_input.audios,
-                    files=run_input.files,
+                    images=run_input.images,  # type: ignore
+                    videos=run_input.videos,  # type: ignore
+                    audio=run_input.audios,  # type: ignore
+                    files=run_input.files,  # type: ignore
                     session_id=context_id,
                     user_id=user_id,
                     **kwargs,
@@ -801,7 +801,7 @@ def attach_routes(
                 status_code=400,
                 detail="Entity ID required. Provide 'agentId' in params.message or 'X-Agent-ID' header.",
             )
-        entity: Optional[Union[Agent, Team, Workflow]] = None
+        entity: Optional[Union[Agent, RemoteAgent, Team, RemoteTeam, Workflow, RemoteWorkflow]] = None
         if agents:
             entity = get_agent_by_id(agent_id, agents)
         if not entity and teams:
@@ -834,7 +834,7 @@ def attach_routes(
                     **kwargs,
                 )
             else:
-                event_stream = entity.arun(  # type: ignore[assignment]
+                event_stream = entity.arun(  # type: ignore
                     input=run_input.input_content,
                     images=run_input.images,
                     videos=run_input.videos,

agno/os/interfaces/agui/agui.py

@@ -1,13 +1,15 @@
 """Main class for the AG-UI app, used to expose an Agno Agent or Team in an AG-UI compatible format."""
 
-from typing import List, Optional
+from typing import List, Optional, Union
 
 from fastapi.routing import APIRouter
 
 from agno.agent import Agent
+from agno.agent.remote import RemoteAgent
 from agno.os.interfaces.agui.router import attach_routes
 from agno.os.interfaces.base import BaseInterface
 from agno.team import Team
+from agno.team.remote import RemoteTeam
 
 
 class AGUI(BaseInterface):
@@ -17,8 +19,8 @@ class AGUI(BaseInterface):
 
     def __init__(
         self,
-        agent: Optional[Agent] = None,
-        team: Optional[Team] = None,
+        agent: Optional[Union[Agent, RemoteAgent]] = None,
+        team: Optional[Union[Team, RemoteTeam]] = None,
         prefix: str = "",
         tags: Optional[List[str]] = None,
     ):