agno 2.3.26__py3-none-any.whl → 2.4.1__py3-none-any.whl

agno/os/routers/components/components.py

@@ -0,0 +1,475 @@
+import logging
+import time
+from typing import Any, Dict, List, Optional, Union
+
+from fastapi import APIRouter, Body, Depends, HTTPException, Path, Query
+
+from agno.db.base import AsyncBaseDb, BaseDb
+from agno.db.base import ComponentType as DbComponentType
+from agno.os.auth import get_authentication_dependency
+from agno.os.schema import (
+    BadRequestResponse,
+    ComponentConfigResponse,
+    ComponentCreate,
+    ComponentResponse,
+    ComponentType,
+    ComponentUpdate,
+    ConfigCreate,
+    ConfigUpdate,
+    InternalServerErrorResponse,
+    NotFoundResponse,
+    PaginatedResponse,
+    PaginationInfo,
+    UnauthenticatedResponse,
+    ValidationErrorResponse,
+)
+from agno.os.settings import AgnoAPISettings
+from agno.registry import Registry
+from agno.utils.log import log_error, log_warning
+from agno.utils.string import generate_id_from_name
+
+logger = logging.getLogger(__name__)
+
+
+def _resolve_db_in_config(
+    config: Dict[str, Any],
+    os_db: BaseDb,
+    registry: Optional[Registry] = None,
+) -> Dict[str, Any]:
+    """
+    Resolve db reference in config by looking up in registry or OS db.
+
+    If config contains a db dict with an id, this function will:
+    1. Check if the id matches the OS db
+    2. Check if the id exists in the registry
+    3. Convert the found db to a dict for serialization
+
+    Args:
+        config: The config dict that may contain a db reference
+        os_db: The OS database instance
+        registry: Optional registry containing registered databases
+
+    Returns:
+        Updated config dict with resolved db
+    """
+    component_db = config.get("db")
+    if component_db is not None and isinstance(component_db, dict):
+        component_db_id = component_db.get("id")
+        if component_db_id is not None:
+            resolved_db = None
+            # First check if it matches the OS db
+            if component_db_id == os_db.id:
+                resolved_db = os_db
+            # Then check the registry
+            elif registry is not None:
+                resolved_db = registry.get_db(component_db_id)
+
+            # Store the full db dict for serialization
+            if resolved_db is not None:
+                config["db"] = resolved_db.to_dict()
+            else:
+                log_error(f"Could not resolve db with id: {component_db_id}")
+    elif component_db is None and "db" in config:
+        # Explicitly set to None, remove the key
+        config.pop("db", None)
+
+    return config
+
+
+def get_components_router(
+    os_db: Union[BaseDb, AsyncBaseDb],
+    settings: AgnoAPISettings = AgnoAPISettings(),
+    registry: Optional[Registry] = None,
+) -> APIRouter:
+    """Create components router."""
+    router = APIRouter(
+        dependencies=[Depends(get_authentication_dependency(settings))],
+        tags=["Components"],
+        responses={
+            400: {"description": "Bad Request", "model": BadRequestResponse},
+            401: {"description": "Unauthorized", "model": UnauthenticatedResponse},
+            404: {"description": "Not Found", "model": NotFoundResponse},
+            422: {"description": "Validation Error", "model": ValidationErrorResponse},
+            500: {"description": "Internal Server Error", "model": InternalServerErrorResponse},
+        },
+    )
+    return attach_routes(router=router, os_db=os_db, registry=registry)
+
+
+def attach_routes(
+    router: APIRouter, os_db: Union[BaseDb, AsyncBaseDb], registry: Optional[Registry] = None
+) -> APIRouter:
+    # Component routes require sync database
+    if not isinstance(os_db, BaseDb):
+        raise ValueError("Component routes require a sync database (BaseDb), not an async database.")
+    db: BaseDb = os_db  # Type narrowed after isinstance check
+
+    @router.get(
+        "/components",
+        response_model=PaginatedResponse[ComponentResponse],
+        response_model_exclude_none=True,
+        status_code=200,
+        operation_id="list_components",
+        summary="List Components",
+        description="Retrieve a paginated list of components with optional filtering by type.",
+    )
+    async def list_components(
+        component_type: Optional[ComponentType] = Query(None, description="Filter by type: agent, team, workflow"),
+        page: int = Query(1, ge=1, description="Page number"),
+        limit: int = Query(20, ge=1, le=100, description="Items per page"),
+    ) -> PaginatedResponse[ComponentResponse]:
+        try:
+            start_time_ms = time.time() * 1000
+            offset = (page - 1) * limit
+
+            components, total_count = db.list_components(
+                component_type=DbComponentType(component_type.value) if component_type else None,
+                limit=limit,
+                offset=offset,
+            )
+
+            total_pages = (total_count + limit - 1) // limit if limit > 0 else 0
+
+            return PaginatedResponse(
+                data=[ComponentResponse(**c) for c in components],
+                meta=PaginationInfo(
+                    page=page,
+                    limit=limit,
+                    total_pages=total_pages,
+                    total_count=total_count,
+                    search_time_ms=round(time.time() * 1000 - start_time_ms, 2),
+                ),
+            )
+        except Exception as e:
+            log_error(f"Error listing components: {e}")
+            raise HTTPException(status_code=500, detail="Internal server error")
+
+    @router.post(
+        "/components",
+        response_model=ComponentResponse,
+        response_model_exclude_none=True,
+        status_code=201,
+        operation_id="create_component",
+        summary="Create Component",
+        description="Create a new component (agent, team, or workflow) with initial config.",
+    )
+    async def create_component(
+        body: ComponentCreate,
+    ) -> ComponentResponse:
+        try:
+            component_id = body.component_id
+            if component_id is None:
+                component_id = generate_id_from_name(body.name)
+
+            # TODO: Create links from config
+
+            # Prepare config - ensure it's a dict and resolve db reference
+            config = body.config or {}
+            config = _resolve_db_in_config(config, db, registry)
+
+            # Warn if creating a team without members
+            if body.component_type == ComponentType.TEAM:
+                members = config.get("members")
+                if not members or len(members) == 0:
+                    log_warning(
+                        f"Creating team '{body.name}' without members. "
+                        "If this is unintended, add members to the config."
+                    )
+
+            component, _config = db.create_component_with_config(
+                component_id=component_id,
+                component_type=DbComponentType(body.component_type.value),
+                name=body.name,
+                description=body.description,
+                metadata=body.metadata,
+                config=config,
+                label=body.label,
+                stage=body.stage or "draft",
+                notes=body.notes,
+            )
+
+            return ComponentResponse(**component)
+        except ValueError as e:
+            raise HTTPException(status_code=400, detail=str(e))
+        except Exception as e:
+            log_error(f"Error creating component: {e}")
+            raise HTTPException(status_code=500, detail="Internal server error")
+
+    @router.get(
+        "/components/{component_id}",
+        response_model=ComponentResponse,
+        response_model_exclude_none=True,
+        status_code=200,
+        operation_id="get_component",
+        summary="Get Component",
+        description="Retrieve a component by ID.",
+    )
+    async def get_component(
+        component_id: str = Path(description="Component ID"),
+    ) -> ComponentResponse:
+        try:
+            component = db.get_component(component_id)
+            if component is None:
+                raise HTTPException(status_code=404, detail=f"Component {component_id} not found")
+            return ComponentResponse(**component)
+        except HTTPException:
+            raise
+        except Exception as e:
+            log_error(f"Error getting component: {e}")
+            raise HTTPException(status_code=500, detail="Internal server error")
+
+    @router.patch(
+        "/components/{component_id}",
+        response_model=ComponentResponse,
+        response_model_exclude_none=True,
+        status_code=200,
+        operation_id="update_component",
+        summary="Update Component",
+        description="Partially update a component by ID.",
+    )
+    async def update_component(
+        component_id: str = Path(description="Component ID"),
+        body: ComponentUpdate = Body(description="Component fields to update"),
+    ) -> ComponentResponse:
+        try:
+            existing = db.get_component(component_id)
+            if existing is None:
+                raise HTTPException(status_code=404, detail=f"Component {component_id} not found")
+
+            update_kwargs: Dict[str, Any] = {"component_id": component_id}
+            if body.name is not None:
+                update_kwargs["name"] = body.name
+            if body.description is not None:
+                update_kwargs["description"] = body.description
+            if body.metadata is not None:
+                update_kwargs["metadata"] = body.metadata
+            if body.component_type is not None:
+                update_kwargs["component_type"] = DbComponentType(body.component_type)
+
+            component = db.upsert_component(**update_kwargs)
+            return ComponentResponse(**component)
+        except HTTPException:
+            raise
+        except ValueError as e:
+            raise HTTPException(status_code=400, detail=str(e))
+        except Exception as e:
+            log_error(f"Error updating component: {e}")
+            raise HTTPException(status_code=500, detail="Internal server error")
+
+    @router.delete(
+        "/components/{component_id}",
+        status_code=204,
+        operation_id="delete_component",
+        summary="Delete Component",
+        description="Delete a component by ID.",
+    )
+    async def delete_component(
+        component_id: str = Path(description="Component ID"),
+    ) -> None:
+        try:
+            deleted = db.delete_component(component_id)
+            if not deleted:
+                raise HTTPException(status_code=404, detail=f"Component {component_id} not found")
+        except HTTPException:
+            raise
+        except Exception as e:
+            log_error(f"Error deleting component: {e}")
+            raise HTTPException(status_code=500, detail="Internal server error")
+
+    @router.get(
+        "/components/{component_id}/configs",
+        response_model=List[ComponentConfigResponse],
+        response_model_exclude_none=True,
+        status_code=200,
+        operation_id="list_configs",
+        summary="List Configs",
+        description="List all configs for a component.",
+    )
+    async def list_configs(
+        component_id: str = Path(description="Component ID"),
+        include_config: bool = Query(True, description="Include full config blob"),
+    ) -> List[ComponentConfigResponse]:
+        try:
+            configs = db.list_configs(component_id, include_config=include_config)
+            return [ComponentConfigResponse(**c) for c in configs]
+        except Exception as e:
+            log_error(f"Error listing configs: {e}")
+            raise HTTPException(status_code=500, detail="Internal server error")
+
+    @router.post(
+        "/components/{component_id}/configs",
+        response_model=ComponentConfigResponse,
+        response_model_exclude_none=True,
+        status_code=201,
+        operation_id="create_config",
+        summary="Create Config Version",
+        description="Create a new config version for a component.",
+    )
+    async def create_config(
+        component_id: str = Path(description="Component ID"),
+        body: ConfigCreate = Body(description="Config data"),
+    ) -> ComponentConfigResponse:
+        try:
+            # Resolve db from config if present
+            config_data = body.config or {}
+            config_data = _resolve_db_in_config(config_data, db, registry)
+
+            config = db.upsert_config(
+                component_id=component_id,
+                version=None,  # Always create new
+                config=config_data,
+                label=body.label,
+                stage=body.stage,
+                notes=body.notes,
+                links=body.links,
+            )
+            return ComponentConfigResponse(**config)
+        except ValueError as e:
+            raise HTTPException(status_code=400, detail=str(e))
+        except Exception as e:
+            log_error(f"Error creating config: {e}")
+            raise HTTPException(status_code=500, detail="Internal server error")
+
+    @router.patch(
+        "/components/{component_id}/configs/{version}",
+        response_model=ComponentConfigResponse,
+        response_model_exclude_none=True,
+        status_code=200,
+        operation_id="update_config",
+        summary="Update Draft Config",
+        description="Update an existing draft config. Cannot update published configs.",
+    )
+    async def update_config(
+        component_id: str = Path(description="Component ID"),
+        version: int = Path(description="Version number"),
+        body: ConfigUpdate = Body(description="Config fields to update"),
+    ) -> ComponentConfigResponse:
+        try:
+            # Resolve db from config if present
+            config_data = body.config
+            if config_data is not None:
+                config_data = _resolve_db_in_config(config_data, db, registry)
+
+            config = db.upsert_config(
+                component_id=component_id,
+                version=version,  # Always update existing
+                config=config_data,
+                label=body.label,
+                stage=body.stage,
+                notes=body.notes,
+                links=body.links,
+            )
+            return ComponentConfigResponse(**config)
+        except ValueError as e:
+            raise HTTPException(status_code=400, detail=str(e))
+        except Exception as e:
+            log_error(f"Error updating config: {e}")
+            raise HTTPException(status_code=500, detail="Internal server error")
+
+    @router.get(
+        "/components/{component_id}/configs/current",
+        response_model=ComponentConfigResponse,
+        response_model_exclude_none=True,
+        status_code=200,
+        operation_id="get_current_config",
+        summary="Get Current Config",
+        description="Get the current config version for a component.",
+    )
+    async def get_current_config(
+        component_id: str = Path(description="Component ID"),
+    ) -> ComponentConfigResponse:
+        try:
+            config = db.get_config(component_id)
+            if config is None:
+                raise HTTPException(status_code=404, detail=f"No current config for {component_id}")
+            return ComponentConfigResponse(**config)
+        except HTTPException:
+            raise
+        except Exception as e:
+            log_error(f"Error getting config: {e}")
+            raise HTTPException(status_code=500, detail="Internal server error")
+
+    @router.get(
+        "/components/{component_id}/configs/{version}",
+        response_model=ComponentConfigResponse,
+        response_model_exclude_none=True,
+        status_code=200,
+        operation_id="get_config",
+        summary="Get Config Version",
+        description="Get a specific config version by number.",
+    )
+    async def get_config_version(
+        component_id: str = Path(description="Component ID"),
+        version: int = Path(description="Version number"),
+    ) -> ComponentConfigResponse:
+        try:
+            config = db.get_config(component_id, version=version)
+
+            if config is None:
+                raise HTTPException(status_code=404, detail=f"Config {component_id} v{version} not found")
+            return ComponentConfigResponse(**config)
+        except HTTPException:
+            raise
+        except Exception as e:
+            log_error(f"Error getting config: {e}")
+            raise HTTPException(status_code=500, detail="Internal server error")
+
+    @router.delete(
+        "/components/{component_id}/configs/{version}",
+        status_code=204,
+        operation_id="delete_config",
+        summary="Delete Config Version",
+        description="Delete a specific draft config version. Cannot delete published or current configs.",
+    )
+    async def delete_config_version(
+        component_id: str = Path(description="Component ID"),
+        version: int = Path(description="Version number"),
+    ) -> None:
+        try:
+            # Resolve version number
+            deleted = db.delete_config(component_id, version=version)
+            if not deleted:
+                raise HTTPException(status_code=404, detail=f"Config {component_id} v{version} not found")
+        except HTTPException:
+            raise
+        except ValueError as e:
+            raise HTTPException(status_code=400, detail=str(e))
+        except Exception as e:
+            log_error(f"Error deleting config: {e}")
+            raise HTTPException(status_code=500, detail="Internal server error")
+
+    @router.post(
+        "/components/{component_id}/configs/{version}/set-current",
+        response_model=ComponentResponse,
+        response_model_exclude_none=True,
+        status_code=200,
+        operation_id="set_current_config",
+        summary="Set Current Config Version",
+        description="Set a published config version as current (for rollback).",
+    )
+    async def set_current_config(
+        component_id: str = Path(description="Component ID"),
+        version: int = Path(description="Version number"),
+    ) -> ComponentResponse:
+        try:
+            success = db.set_current_version(component_id, version=version)
+            if not success:
+                raise HTTPException(
+                    status_code=404, detail=f"Component {component_id} or config version {version} not found"
+                )
+
+            # Fetch and return updated component
+            component = db.get_component(component_id)
+            if component is None:
+                raise HTTPException(status_code=404, detail=f"Component {component_id} not found")
+
+            return ComponentResponse(**component)
+        except HTTPException:
+            raise
+        except ValueError as e:
+            raise HTTPException(status_code=400, detail=str(e))
+        except Exception as e:
+            log_error(f"Error setting current config: {e}")
+            raise HTTPException(status_code=500, detail="Internal server error")
+
+    return router

agno/os/routers/evals/schemas.py

@@ -1,5 +1,5 @@
 from dataclasses import asdict
-from datetime import datetime, timezone
+from datetime import datetime
 from typing import Any, Dict, List, Literal, Optional
 
 from pydantic import BaseModel, Field
@@ -10,6 +10,7 @@ from agno.eval.accuracy import AccuracyEval
 from agno.eval.agent_as_judge import AgentAsJudgeEval
 from agno.eval.performance import PerformanceEval
 from agno.eval.reliability import ReliabilityEval
+from agno.os.utils import to_utc_datetime
 
 
 class EvalRunInput(BaseModel):
@@ -74,8 +75,8 @@ class EvalSchema(BaseModel):
             eval_type=eval_run["eval_type"],
             eval_data=eval_run["eval_data"],
             eval_input=eval_run.get("eval_input"),
-            created_at=datetime.fromtimestamp(eval_run["created_at"], tz=timezone.utc),
-            updated_at=datetime.fromtimestamp(eval_run["updated_at"], tz=timezone.utc),
+            created_at=to_utc_datetime(eval_run.get("created_at")),
+            updated_at=to_utc_datetime(eval_run.get("updated_at")),
         )
 
     @classmethod

agno/os/routers/health.py

@@ -8,7 +8,7 @@ from agno.os.schema import HealthResponse
 def get_health_router(health_endpoint: str = "/health") -> APIRouter:
     router = APIRouter(tags=["Health"])
 
-    started_time_stamp = datetime.now(timezone.utc).timestamp()
+    started_at = datetime.now(timezone.utc)
 
     @router.get(
         health_endpoint,
@@ -20,12 +20,12 @@ def get_health_router(health_endpoint: str = "/health") -> APIRouter:
             200: {
                 "description": "API is healthy and operational",
                 "content": {
-                    "application/json": {"example": {"status": "ok", "instantiated_at": str(started_time_stamp)}}
+                    "application/json": {"example": {"status": "ok", "instantiated_at": "2025-06-10T12:00:00Z"}}
                 },
             }
         },
     )
     async def health_check() -> HealthResponse:
-        return HealthResponse(status="ok", instantiated_at=str(started_time_stamp))
+        return HealthResponse(status="ok", instantiated_at=started_at)
 
     return router

agno/os/routers/knowledge/knowledge.py

@@ -206,6 +206,113 @@ def attach_routes(router: APIRouter, knowledge_instances: List[Union[Knowledge,
         )
         return response
 
+    @router.post(
+        "/knowledge/remote-content",
+        response_model=ContentResponseSchema,
+        status_code=202,
+        operation_id="upload_remote_content",
+        summary="Upload Remote Content",
+        description=(
+            "Upload content from a remote source (S3, GCS, SharePoint, GitHub) to the knowledge base. "
+            "Content is processed asynchronously in the background. "
+            "Use the /knowledge/config endpoint to see available remote content sources."
+        ),
+        responses={
+            202: {
+                "description": "Remote content upload accepted for processing",
+                "content": {
+                    "application/json": {
+                        "example": {
+                            "id": "content-456",
+                            "name": "reports/q1-2024.pdf",
+                            "description": "Q1 Report from S3",
+                            "metadata": {"source": "s3-docs"},
+                            "status": "processing",
+                        }
+                    }
+                },
+            },
+            400: {
+                "description": "Invalid request - unknown config or missing path",
+                "model": BadRequestResponse,
+            },
+            422: {"description": "Validation error in request body", "model": ValidationErrorResponse},
+        },
+    )
+    async def upload_remote_content(
+        request: Request,
+        background_tasks: BackgroundTasks,
+        config_id: str = Form(..., description="ID of the configured remote content source (from /knowledge/config)"),
+        path: str = Form(..., description="Path to file or folder in the remote source"),
+        name: Optional[str] = Form(None, description="Content name (auto-generated if not provided)"),
+        description: Optional[str] = Form(None, description="Content description"),
+        metadata: Optional[str] = Form(None, description="JSON metadata object"),
+        reader_id: Optional[str] = Form(None, description="ID of the reader to use for processing"),
+        chunker: Optional[str] = Form(None, description="Chunking strategy to apply"),
+        chunk_size: Optional[int] = Form(None, description="Chunk size for processing"),
+        chunk_overlap: Optional[int] = Form(None, description="Chunk overlap for processing"),
+        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)
+
+        if isinstance(knowledge, RemoteKnowledge):
+            # TODO: Forward to remote knowledge instance
+            raise HTTPException(status_code=501, detail="Remote content upload not yet supported for RemoteKnowledge")
+
+        # Validate that the config_id exists in configured sources
+        config = knowledge._get_remote_config_by_id(config_id)
+        if config is None:
+            raise HTTPException(
+                status_code=400,
+                detail=f"Unknown content source: {config_id}. Check /knowledge/config for available sources.",
+            )
+
+        # Parse metadata if provided
+        parsed_metadata = None
+        if metadata:
+            try:
+                parsed_metadata = json.loads(metadata)
+            except json.JSONDecodeError:
+                parsed_metadata = {"value": metadata}
+
+        # Use the config's factory methods to create the remote content object
+        # If path ends with '/', treat as folder, otherwise treat as file
+        is_folder = path.endswith("/")
+        if is_folder:
+            if hasattr(config, "folder"):
+                remote_content = config.folder(path.rstrip("/"))
+            else:
+                raise HTTPException(status_code=400, detail=f"Config {config_id} does not support folder uploads")
+        else:
+            if hasattr(config, "file"):
+                remote_content = config.file(path)
+            else:
+                raise HTTPException(status_code=400, detail=f"Config {config_id} does not support file uploads")
+
+        # Set name from path if not provided
+        content_name = name or path
+
+        content = Content(
+            name=content_name,
+            description=description,
+            metadata=parsed_metadata,
+            remote_content=remote_content,
+        )
+        content_hash = knowledge._build_content_hash(content)
+        content.content_hash = content_hash
+        content.id = generate_id(content_hash)
+
+        background_tasks.add_task(process_content, knowledge, content, reader_id, chunker, chunk_size, chunk_overlap)
+
+        response = ContentResponseSchema(
+            id=content.id,
+            name=content_name,
+            description=description,
+            metadata=parsed_metadata,
+            status=ContentStatus.PROCESSING,
+        )
+        return response
+
     @router.patch(
         "/knowledge/content/{content_id}",
         response_model=ContentResponseSchema,
@@ -671,7 +778,7 @@ def attach_routes(router: APIRouter, knowledge_instances: List[Union[Knowledge,
         # Use max_results if specified, otherwise use a higher limit for search then paginate
         search_limit = request.max_results
 
-        results = await knowledge.async_search(
+        results = await knowledge.asearch(
             query=request.query, max_results=search_limit, filters=request.filters, search_type=request.search_type
         )
 
@@ -1047,13 +1154,31 @@ def attach_routes(router: APIRouter, knowledge_instances: List[Union[Knowledge,
                     search_types=search_types,
                 )
             )
-        filters = await knowledge.async_get_valid_filters()
+        filters = await knowledge.aget_valid_filters()
+
+        # Get remote content sources if available
+        remote_content_sources = None
+        if hasattr(knowledge, "_get_remote_configs") and callable(knowledge._get_remote_configs):
+            remote_configs = knowledge._get_remote_configs()
+            if remote_configs:
+                from agno.os.routers.knowledge.schemas import RemoteContentSourceSchema
+
+                remote_content_sources = [
+                    RemoteContentSourceSchema(
+                        id=config.id,
+                        name=config.name,
+                        type=config.__class__.__name__.replace("Config", "").lower(),
+                        metadata=config.metadata,
+                    )
+                    for config in remote_configs
+                ]
         return ConfigResponseSchema(
             readers=reader_schemas,
             vector_dbs=vector_dbs,
             readersForType=types_of_readers,
             chunkers=chunkers_dict,
             filters=filters,
+            remote_content_sources=remote_content_sources,
         )
 
     return router
@@ -1098,7 +1223,7 @@ async def process_content(
             log_debug(f"Set chunking strategy: {chunker}")
 
         log_debug(f"Using reader: {content.reader.__class__.__name__}")
-        await knowledge._load_content_async(content, upsert=False, skip_if_exists=True)
+        await knowledge._aload_content(content, upsert=False, skip_if_exists=True)
         log_info(f"Content {content.id} processed successfully")
     except Exception as e:
         log_info(f"Error processing content: {e}")