agno 2.3.16__py3-none-any.whl → 2.3.18__py3-none-any.whl

agno/os/routers/evals/evals.py

@@ -2,13 +2,13 @@ import logging
 from copy import deepcopy
 from typing import List, Optional, Union, cast
 
-from fastapi import APIRouter, Depends, HTTPException, Query
+from fastapi import APIRouter, Depends, HTTPException, Query, Request
 
-from agno.agent.agent import Agent
+from agno.agent import Agent, RemoteAgent
 from agno.db.base import AsyncBaseDb, BaseDb
 from agno.db.schemas.evals import EvalFilterType, EvalType
 from agno.models.utils import get_model
-from agno.os.auth import get_authentication_dependency
+from agno.os.auth import get_auth_token_from_request, get_authentication_dependency
 from agno.os.routers.evals.schemas import (
     DeleteEvalRunsRequest,
     EvalRunInput,
@@ -33,15 +33,17 @@ from agno.os.schema import (
 )
 from agno.os.settings import AgnoAPISettings
 from agno.os.utils import get_agent_by_id, get_db, get_team_by_id
-from agno.team.team import Team
+from agno.remote.base import RemoteDb
+from agno.team import RemoteTeam, Team
+from agno.utils.log import log_warning
 
 logger = logging.getLogger(__name__)
 
 
 def get_eval_router(
-    dbs: dict[str, list[Union[BaseDb, AsyncBaseDb]]],
-    agents: Optional[List[Agent]] = None,
-    teams: Optional[List[Team]] = None,
+    dbs: dict[str, list[Union[BaseDb, AsyncBaseDb, RemoteDb]]],
+    agents: Optional[List[Union[Agent, RemoteAgent]]] = None,
+    teams: Optional[List[Union[Team, RemoteTeam]]] = None,
     settings: AgnoAPISettings = AgnoAPISettings(),
 ) -> APIRouter:
     """Create eval router with comprehensive OpenAPI documentation for agent/team evaluation endpoints."""
@@ -61,9 +63,9 @@ def get_eval_router(
 
 def attach_routes(
     router: APIRouter,
-    dbs: dict[str, list[Union[BaseDb, AsyncBaseDb]]],
-    agents: Optional[List[Agent]] = None,
-    teams: Optional[List[Team]] = None,
+    dbs: dict[str, list[Union[BaseDb, AsyncBaseDb, RemoteDb]]],
+    agents: Optional[List[Union[Agent, RemoteAgent]]] = None,
+    teams: Optional[List[Union[Team, RemoteTeam]]] = None,
 ) -> APIRouter:
     @router.get(
         "/eval-runs",
@@ -109,6 +111,7 @@ def attach_routes(
         },
     )
     async def get_eval_runs(
+        request: Request,
         agent_id: Optional[str] = Query(default=None, description="Agent ID"),
         team_id: Optional[str] = Query(default=None, description="Team ID"),
         workflow_id: Optional[str] = Query(default=None, description="Workflow ID"),
@@ -124,6 +127,23 @@ def attach_routes(
     ) -> PaginatedResponse[EvalSchema]:
         db = await get_db(dbs, db_id, table)
 
+        if isinstance(db, RemoteDb):
+            auth_token = get_auth_token_from_request(request)
+            headers = {"Authorization": f"Bearer {auth_token}"} if auth_token else None
+            return await db.get_eval_runs(
+                limit=limit,
+                page=page,
+                sort_by=sort_by,
+                sort_order=sort_order.value if sort_order else None,
+                agent_id=agent_id,
+                team_id=team_id,
+                workflow_id=workflow_id,
+                model_id=model_id,
+                eval_types=eval_types,
+                filter_type=filter_type.value if filter_type else None,
+                headers=headers,
+            )
+
         # TODO: Delete me:
         # Filtering out agent-as-judge by default for now,
         # as they are not supported yet in the AgentOS UI.
@@ -211,11 +231,17 @@ def attach_routes(
         },
     )
     async def get_eval_run(
+        request: Request,
         eval_run_id: str,
         db_id: Optional[str] = Query(default=None, description="The ID of the database to use"),
         table: Optional[str] = Query(default=None, description="Table to query eval run from"),
     ) -> EvalSchema:
         db = await get_db(dbs, db_id, table)
+        if isinstance(db, RemoteDb):
+            auth_token = get_auth_token_from_request(request)
+            headers = {"Authorization": f"Bearer {auth_token}"} if auth_token else None
+            return await db.get_eval_run(eval_run_id=eval_run_id, db_id=db_id, table=table, headers=headers)
+
         if isinstance(db, AsyncBaseDb):
             db = cast(AsyncBaseDb, db)
             eval_run = await db.get_eval_run(eval_run_id=eval_run_id, deserialize=False)
@@ -238,12 +264,20 @@ def attach_routes(
         },
     )
     async def delete_eval_runs(
+        http_request: Request,
         request: DeleteEvalRunsRequest,
         db_id: Optional[str] = Query(default=None, description="Database ID to use for deletion"),
         table: Optional[str] = Query(default=None, description="Table to use for deletion"),
     ) -> None:
         try:
             db = await get_db(dbs, db_id, table)
+            if isinstance(db, RemoteDb):
+                auth_token = get_auth_token_from_request(http_request)
+                headers = {"Authorization": f"Bearer {auth_token}"} if auth_token else None
+                return await db.delete_eval_runs(
+                    eval_run_ids=request.eval_run_ids, db_id=db_id, table=table, headers=headers
+                )
+
             if isinstance(db, AsyncBaseDb):
                 db = cast(AsyncBaseDb, db)
                 await db.delete_eval_runs(eval_run_ids=request.eval_run_ids)
@@ -291,6 +325,7 @@ def attach_routes(
         },
     )
     async def update_eval_run(
+        http_request: Request,
         eval_run_id: str,
         request: UpdateEvalRunRequest,
         db_id: Optional[str] = Query(default=None, description="The ID of the database to use"),
@@ -298,6 +333,13 @@ def attach_routes(
     ) -> EvalSchema:
         try:
             db = await get_db(dbs, db_id, table)
+            if isinstance(db, RemoteDb):
+                auth_token = get_auth_token_from_request(http_request)
+                headers = {"Authorization": f"Bearer {auth_token}"} if auth_token else None
+                return await db.update_eval_run(
+                    eval_run_id=eval_run_id, name=request.name, db_id=db_id, table=table, headers=headers
+                )
+
             if isinstance(db, AsyncBaseDb):
                 db = cast(AsyncBaseDb, db)
                 eval_run = await db.rename_eval_run(eval_run_id=eval_run_id, name=request.name, deserialize=False)
@@ -352,11 +394,29 @@ def attach_routes(
         },
     )
     async def run_eval(
+        request: Request,
         eval_run_input: EvalRunInput,
         db_id: Optional[str] = Query(default=None, description="Database ID to use for evaluation"),
         table: Optional[str] = Query(default=None, description="Table to use for evaluation"),
     ) -> Optional[EvalSchema]:
         db = await get_db(dbs, db_id, table)
+        if isinstance(db, RemoteDb):
+            auth_token = get_auth_token_from_request(request)
+            headers = {"Authorization": f"Bearer {auth_token}"} if auth_token else None
+            return await db.create_eval_run(
+                eval_type=eval_run_input.eval_type,
+                input_text=eval_run_input.input,
+                agent_id=eval_run_input.agent_id,
+                team_id=eval_run_input.team_id,
+                model_id=eval_run_input.model_id,
+                model_provider=eval_run_input.model_provider,
+                expected_output=eval_run_input.expected_output,
+                expected_tool_calls=eval_run_input.expected_tool_calls,
+                num_iterations=eval_run_input.num_iterations,
+                db_id=db_id,
+                table=table,
+                headers=headers,
+            )
 
         if eval_run_input.agent_id and eval_run_input.team_id:
             raise HTTPException(status_code=400, detail="Only one of agent_id or team_id must be provided")
@@ -365,6 +425,9 @@ def attach_routes(
             agent = get_agent_by_id(agent_id=eval_run_input.agent_id, agents=agents)
             if not agent:
                 raise HTTPException(status_code=404, detail=f"Agent with id '{eval_run_input.agent_id}' not found")
+            if isinstance(agent, RemoteAgent):
+                log_warning("Evaluation against remote agents are not supported yet")
+                return None
 
             default_model = None
             if (
@@ -387,6 +450,9 @@ def attach_routes(
             team = get_team_by_id(team_id=eval_run_input.team_id, teams=teams)
             if not team:
                 raise HTTPException(status_code=404, detail=f"Team with id '{eval_run_input.team_id}' not found")
+            if isinstance(team, RemoteTeam):
+                log_warning("Evaluation against remote teams are not supported yet")
+                return None
 
             # If model_id/model_provider specified, override team's model temporarily
             default_model = None
@@ -411,21 +477,37 @@ def attach_routes(
 
         # Run the evaluation
         if eval_run_input.eval_type == EvalType.ACCURACY:
+            if isinstance(agent, RemoteAgent) or isinstance(team, RemoteTeam):
+                # TODO: Handle remote evaluation
+                log_warning("Evaluation against remote agents are not supported yet")
+                return None
             return await run_accuracy_eval(
                 eval_run_input=eval_run_input, db=db, agent=agent, team=team, default_model=default_model
             )
 
         elif eval_run_input.eval_type == EvalType.AGENT_AS_JUDGE:
             return await run_agent_as_judge_eval(
-                eval_run_input=eval_run_input, db=db, agent=agent, team=team, default_model=default_model
+                eval_run_input=eval_run_input,
+                db=db,
+                agent=agent,
+                team=team,
+                default_model=default_model,  # type: ignore
             )
 
         elif eval_run_input.eval_type == EvalType.PERFORMANCE:
+            if isinstance(agent, RemoteAgent) or isinstance(team, RemoteTeam):
+                # TODO: Handle remote evaluation
+                log_warning("Evaluation against remote agents are not supported yet")
+                return None
             return await run_performance_eval(
                 eval_run_input=eval_run_input, db=db, agent=agent, team=team, default_model=default_model
             )
 
         else:
+            if isinstance(agent, RemoteAgent) or isinstance(team, RemoteTeam):
+                # TODO: Handle remote evaluation
+                log_warning("Evaluation against remote agents are not supported yet")
+                return None
             return await run_reliability_eval(
                 eval_run_input=eval_run_input, db=db, agent=agent, team=team, default_model=default_model
             )

agno/os/routers/evals/utils.py

@@ -2,7 +2,7 @@ from typing import Optional, Union
 
 from fastapi import HTTPException
 
-from agno.agent.agent import Agent
+from agno.agent import Agent, RemoteAgent
 from agno.db.base import AsyncBaseDb, BaseDb
 from agno.eval.accuracy import AccuracyEval
 from agno.eval.agent_as_judge import AgentAsJudgeEval
@@ -10,7 +10,7 @@ from agno.eval.performance import PerformanceEval
 from agno.eval.reliability import ReliabilityEval
 from agno.models.base import Model
 from agno.os.routers.evals.schemas import EvalRunInput, EvalSchema
-from agno.team.team import Team
+from agno.team import RemoteTeam, Team
 
 
 async def run_accuracy_eval(
@@ -56,8 +56,8 @@ async def run_accuracy_eval(
 async def run_agent_as_judge_eval(
     eval_run_input: EvalRunInput,
     db: Union[BaseDb, AsyncBaseDb],
-    agent: Optional[Agent] = None,
-    team: Optional[Team] = None,
+    agent: Optional[Union[Agent, RemoteAgent]] = None,
+    team: Optional[Union[Team, RemoteTeam]] = None,
     default_model: Optional[Model] = None,
 ) -> EvalSchema:
     """Run an AgentAsJudge evaluation for the given agent or team"""
@@ -109,9 +109,9 @@ async def run_agent_as_judge_eval(
 
     # Restore original model after eval
     if default_model is not None:
-        if agent is not None:
+        if agent is not None and isinstance(agent, Agent):
             agent.model = default_model
-        elif team is not None:
+        elif team is not None and isinstance(team, Team):
             team.model = default_model
 
     return eval_run

agno/os/routers/knowledge/knowledge.py

@@ -1,16 +1,16 @@
 import json
 import logging
 import math
-from typing import Any, Dict, List, Optional
+from typing import Any, Dict, List, Optional, Union
 
-from fastapi import APIRouter, BackgroundTasks, Depends, File, Form, HTTPException, Path, Query, UploadFile
+from fastapi import APIRouter, BackgroundTasks, Depends, File, Form, HTTPException, Path, Query, Request, UploadFile
 
 from agno.knowledge.content import Content, FileData
 from agno.knowledge.knowledge import Knowledge
 from agno.knowledge.reader import ReaderFactory
 from agno.knowledge.reader.base import Reader
 from agno.knowledge.utils import get_all_chunkers_info, get_all_readers_info, get_content_types_to_readers_mapping
-from agno.os.auth import get_authentication_dependency
+from agno.os.auth import get_auth_token_from_request, get_authentication_dependency
 from agno.os.routers.knowledge.schemas import (
     ChunkerSchema,
     ConfigResponseSchema,
@@ -35,6 +35,7 @@ from agno.os.schema import (
 )
 from agno.os.settings import AgnoAPISettings
 from agno.os.utils import get_knowledge_instance_by_db_id
+from agno.remote.base import RemoteKnowledge
 from agno.utils.log import log_debug, log_info
 from agno.utils.string import generate_id
 
@@ -42,7 +43,7 @@ logger = logging.getLogger(__name__)
 
 
 def get_knowledge_router(
-    knowledge_instances: List[Knowledge], settings: AgnoAPISettings = AgnoAPISettings()
+    knowledge_instances: List[Union[Knowledge, RemoteKnowledge]], settings: AgnoAPISettings = AgnoAPISettings()
 ) -> APIRouter:
     """Create knowledge router with comprehensive OpenAPI documentation for content management endpoints."""
     router = APIRouter(
@@ -59,7 +60,7 @@ def get_knowledge_router(
     return attach_routes(router=router, knowledge_instances=knowledge_instances)
 
 
-def attach_routes(router: APIRouter, knowledge_instances: List[Knowledge]) -> APIRouter:
+def attach_routes(router: APIRouter, knowledge_instances: List[Union[Knowledge, RemoteKnowledge]]) -> APIRouter:
     @router.post(
         "/knowledge/content",
         response_model=ContentResponseSchema,
@@ -93,6 +94,7 @@ def attach_routes(router: APIRouter, knowledge_instances: List[Knowledge]) -> AP
         },
     )
     async def upload_content(
+        request: Request,
         background_tasks: BackgroundTasks,
         name: Optional[str] = Form(None, description="Content name (auto-generated from file/URL if not provided)"),
         description: Optional[str] = Form(None, description="Content description for context"),
@@ -107,7 +109,6 @@ def attach_routes(router: APIRouter, knowledge_instances: List[Knowledge]) -> AP
         db_id: Optional[str] = Query(default=None, description="Database ID to use for content storage"),
     ):
         knowledge = get_knowledge_instance_by_db_id(knowledge_instances, db_id)
-        log_info(f"Adding content: {name}, {description}, {url}, {metadata}")
 
         parsed_metadata = None
         if metadata:
@@ -116,6 +117,25 @@ def attach_routes(router: APIRouter, knowledge_instances: List[Knowledge]) -> AP
             except json.JSONDecodeError:
                 # If it's not valid JSON, treat as a simple key-value pair
                 parsed_metadata = {"value": metadata} if metadata != "string" else None
+
+        if isinstance(knowledge, RemoteKnowledge):
+            auth_token = get_auth_token_from_request(request)
+            headers = {"Authorization": f"Bearer {auth_token}"} if auth_token else None
+            return await knowledge.upload_content(
+                name=name,
+                description=description,
+                url=url,
+                metadata=parsed_metadata,
+                file=file,
+                text_content=text_content,
+                reader_id=reader_id,
+                chunker=chunker,
+                chunk_size=chunk_size,
+                chunk_overlap=chunk_overlap,
+                db_id=db_id,
+                headers=headers,
+            )
+
         if file:
             content_bytes = await file.read()
         elif text_content:
@@ -225,6 +245,7 @@ def attach_routes(router: APIRouter, knowledge_instances: List[Knowledge]) -> AP
         },
     )
     async def update_content(
+        request: Request,
         content_id: str = Path(..., description="Content ID"),
         name: Optional[str] = Form(None, description="Content name"),
         description: Optional[str] = Form(None, description="Content description"),
@@ -242,6 +263,19 @@ def attach_routes(router: APIRouter, knowledge_instances: List[Knowledge]) -> AP
             except json.JSONDecodeError:
                 raise HTTPException(status_code=400, detail="Invalid JSON format for metadata")
 
+        if isinstance(knowledge, RemoteKnowledge):
+            auth_token = get_auth_token_from_request(request)
+            headers = {"Authorization": f"Bearer {auth_token}"} if auth_token else None
+            return await knowledge.update_content(
+                content_id=content_id,
+                name=name,
+                description=description,
+                metadata=parsed_metadata,
+                reader_id=reader_id,
+                db_id=db_id,
+                headers=headers,
+            )
+
         # Create ContentUpdateSchema object from form data
         update_data = ContentUpdateSchema(
             name=name if name and name.strip() else None,
@@ -309,6 +343,7 @@ def attach_routes(router: APIRouter, knowledge_instances: List[Knowledge]) -> AP
         },
     )
     async def get_content(
+        request: Request,
         limit: Optional[int] = Query(default=20, description="Number of content entries to return"),
         page: Optional[int] = Query(default=1, description="Page number"),
         sort_by: Optional[str] = Query(default="created_at", description="Field to sort by"),
@@ -316,6 +351,19 @@ def attach_routes(router: APIRouter, knowledge_instances: List[Knowledge]) -> AP
         db_id: Optional[str] = Query(default=None, description="The ID of the database to use"),
     ) -> PaginatedResponse[ContentResponseSchema]:
         knowledge = get_knowledge_instance_by_db_id(knowledge_instances, db_id)
+
+        if isinstance(knowledge, RemoteKnowledge):
+            auth_token = get_auth_token_from_request(request)
+            headers = {"Authorization": f"Bearer {auth_token}"} if auth_token else None
+            return await knowledge.get_content(
+                limit=limit,
+                page=page,
+                sort_by=sort_by,
+                sort_order=sort_order.value if sort_order else None,
+                db_id=db_id,
+                headers=headers,
+            )
+
         contents, count = await knowledge.aget_content(limit=limit, page=page, sort_by=sort_by, sort_order=sort_order)
 
         return PaginatedResponse(
@@ -377,11 +425,16 @@ def attach_routes(router: APIRouter, knowledge_instances: List[Knowledge]) -> AP
         },
     )
     async def get_content_by_id(
+        request: Request,
         content_id: str,
         db_id: Optional[str] = Query(default=None, description="The ID of the database to use"),
     ) -> ContentResponseSchema:
-        log_info(f"Getting content by id: {content_id}")
         knowledge = get_knowledge_instance_by_db_id(knowledge_instances, db_id)
+        if isinstance(knowledge, RemoteKnowledge):
+            auth_token = get_auth_token_from_request(request)
+            headers = {"Authorization": f"Bearer {auth_token}"} if auth_token else None
+            return await knowledge.get_content_by_id(content_id=content_id, db_id=db_id, headers=headers)
+
         content = await knowledge.aget_content_by_id(content_id=content_id)
         if not content:
             raise HTTPException(status_code=404, detail=f"Content not found: {content_id}")
@@ -417,12 +470,17 @@ def attach_routes(router: APIRouter, knowledge_instances: List[Knowledge]) -> AP
         },
     )
     async def delete_content_by_id(
+        request: Request,
         content_id: str,
         db_id: Optional[str] = Query(default=None, description="The ID of the database to use"),
     ) -> ContentResponseSchema:
         knowledge = get_knowledge_instance_by_db_id(knowledge_instances, db_id)
-        await knowledge.aremove_content_by_id(content_id=content_id)
-        log_info(f"Deleting content by id: {content_id}")
+        if isinstance(knowledge, RemoteKnowledge):
+            auth_token = get_auth_token_from_request(request)
+            headers = {"Authorization": f"Bearer {auth_token}"} if auth_token else None
+            await knowledge.delete_content_by_id(content_id=content_id, db_id=db_id, headers=headers)
+        else:
+            await knowledge.aremove_content_by_id(content_id=content_id)
 
         return ContentResponseSchema(
             id=content_id,
@@ -442,12 +500,17 @@ def attach_routes(router: APIRouter, knowledge_instances: List[Knowledge]) -> AP
             500: {"description": "Failed to delete all content", "model": InternalServerErrorResponse},
         },
     )
-    def delete_all_content(
+    async def delete_all_content(
+        request: Request,
         db_id: Optional[str] = Query(default=None, description="The ID of the database to use"),
     ):
         knowledge = get_knowledge_instance_by_db_id(knowledge_instances, db_id)
-        log_info("Deleting all content")
-        knowledge.remove_all_content()
+        if isinstance(knowledge, RemoteKnowledge):
+            auth_token = get_auth_token_from_request(request)
+            headers = {"Authorization": f"Bearer {auth_token}"} if auth_token else None
+            return await knowledge.delete_all_content(db_id=db_id, headers=headers)
+
+        await knowledge.aremove_all_content()
         return "success"
 
     @router.get(
@@ -481,11 +544,16 @@ def attach_routes(router: APIRouter, knowledge_instances: List[Knowledge]) -> AP
         },
     )
     async def get_content_status(
+        request: Request,
         content_id: str,
         db_id: Optional[str] = Query(default=None, description="The ID of the database to use"),
     ) -> ContentStatusResponse:
-        log_info(f"Getting content status: {content_id}")
         knowledge = get_knowledge_instance_by_db_id(knowledge_instances, db_id)
+        if isinstance(knowledge, RemoteKnowledge):
+            auth_token = get_auth_token_from_request(request)
+            headers = {"Authorization": f"Bearer {auth_token}"} if auth_token else None
+            return await knowledge.get_content_status(content_id=content_id, db_id=db_id, headers=headers)
+
         knowledge_status, status_message = await knowledge.aget_content_status(content_id=content_id)
 
         # Handle the case where content is not found
@@ -550,13 +618,27 @@ def attach_routes(router: APIRouter, knowledge_instances: List[Knowledge]) -> AP
             404: {"description": "No documents found"},
         },
     )
-    def search_knowledge(request: VectorSearchRequestSchema) -> PaginatedResponse[VectorSearchResult]:
+    async def search_knowledge(
+        http_request: Request, request: VectorSearchRequestSchema
+    ) -> PaginatedResponse[VectorSearchResult]:
         import time
 
         start_time = time.time()
 
         knowledge = get_knowledge_instance_by_db_id(knowledge_instances, request.db_id)
 
+        if isinstance(knowledge, RemoteKnowledge):
+            auth_token = get_auth_token_from_request(http_request)
+            headers = {"Authorization": f"Bearer {auth_token}"} if auth_token else None
+            return await knowledge.search_knowledge(
+                query=request.query,
+                max_results=request.max_results,
+                filters=request.filters,
+                search_type=request.search_type,
+                db_id=request.db_id,
+                headers=headers,
+            )
+
         # For now, validate the vector db ids exist in the knowledge base
         # We will add more logic around this once we have multi vectordb support
         # If vector db ids are provided, check if any of them match the knowledge's vector db
@@ -578,7 +660,7 @@ def attach_routes(router: APIRouter, knowledge_instances: List[Knowledge]) -> AP
         # Use max_results if specified, otherwise use a higher limit for search then paginate
         search_limit = request.max_results
 
-        results = knowledge.search(
+        results = await knowledge.async_search(
             query=request.query, max_results=search_limit, filters=request.filters, search_type=request.search_type
         )
 
@@ -869,11 +951,17 @@ def attach_routes(router: APIRouter, knowledge_instances: List[Knowledge]) -> AP
             }
         },
     )
-    def get_config(
+    async def get_config(
+        request: Request,
         db_id: Optional[str] = Query(default=None, description="The ID of the database to use"),
     ) -> ConfigResponseSchema:
         knowledge = get_knowledge_instance_by_db_id(knowledge_instances, db_id)
 
+        if isinstance(knowledge, RemoteKnowledge):
+            auth_token = get_auth_token_from_request(request)
+            headers = {"Authorization": f"Bearer {auth_token}"} if auth_token else None
+            return await knowledge.get_config(headers=headers)
+
         # Get factory readers info (including custom readers from this knowledge instance)
         readers_info = get_all_readers_info(knowledge)
         reader_schemas = {}