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

agno/os/routers/registry/registry.py

@@ -0,0 +1,337 @@
+import time
+from typing import Any, Dict, List, Literal, Optional
+
+from fastapi import APIRouter, Depends, HTTPException, Query
+from pydantic import BaseModel, Field
+
+from agno.os.auth import get_authentication_dependency
+from agno.os.schema import (
+    BadRequestResponse,
+    InternalServerErrorResponse,
+    NotFoundResponse,
+    PaginatedResponse,
+    PaginationInfo,
+    UnauthenticatedResponse,
+    ValidationErrorResponse,
+)
+from agno.os.settings import AgnoAPISettings
+from agno.registry import Registry
+from agno.tools.function import Function
+from agno.tools.toolkit import Toolkit
+from agno.utils.log import log_error
+
+ComponentType = Literal["tool", "toolkit", "model", "db", "vector_db", "schema"]
+
+
+# ============================================
+# Response Schema
+# ============================================
+
+
+class ComponentResponse(BaseModel):
+    name: str
+    component_type: ComponentType
+    description: Optional[str] = None
+    metadata: Dict[str, Any] = Field(default_factory=dict)
+    # Tool-specific fields (matching config format)
+    parameters: Optional[Dict[str, Any]] = None
+    requires_confirmation: Optional[bool] = None
+    external_execution: Optional[bool] = None
+
+
+# ============================================
+# Router
+# ============================================
+
+
+def get_registry_router(registry: Registry, settings: AgnoAPISettings = AgnoAPISettings()) -> APIRouter:
+    router = APIRouter(
+        dependencies=[Depends(get_authentication_dependency(settings))],
+        tags=["Registry"],
+        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, registry=registry)
+
+
+def attach_routes(router: APIRouter, registry: Registry) -> APIRouter:
+    def _safe_str(v: Any) -> Optional[str]:
+        if v is None:
+            return None
+        if isinstance(v, str):
+            s = v.strip()
+            return s or None
+        return str(v)
+
+    def _safe_name(obj: Any, fallback: str) -> str:
+        n = getattr(obj, "name", None)
+        n = _safe_str(n)
+        return n or fallback
+
+    def _class_path(obj: Any) -> str:
+        cls = obj.__class__
+        return f"{cls.__module__}.{cls.__name__}"
+
+    def _maybe_jsonable(value: Any) -> Any:
+        # Best-effort: keep only data that is likely JSON serializable
+        # If your Function.parameters is a Pydantic model or custom object, this avoids 500s.
+        if value is None:
+            return None
+        if isinstance(value, (str, int, float, bool)):
+            return value
+        if isinstance(value, list):
+            return [_maybe_jsonable(x) for x in value]
+        if isinstance(value, dict):
+            out: Dict[str, Any] = {}
+            for k, v in value.items():
+                out[str(k)] = _maybe_jsonable(v)
+            return out
+        # Fallback to string to avoid serialization errors
+        return str(value)
+
+    def _get_all_components(include_schema: bool) -> List[ComponentResponse]:
+        components: List[ComponentResponse] = []
+
+        # Tools
+        for tool in getattr(registry, "tools", []) or []:
+            if isinstance(tool, Toolkit):
+                toolkit_name = _safe_name(tool, fallback=tool.__class__.__name__)
+                functions = getattr(tool, "functions", {}) or {}
+
+                components.append(
+                    ComponentResponse(
+                        name=toolkit_name,
+                        component_type="toolkit",
+                        description=_safe_str(getattr(tool, "description", None)),
+                        metadata={
+                            "class_path": _class_path(tool),
+                            "functions": sorted(list(functions.keys())),
+                        },
+                    )
+                )
+
+                # Also expose individual functions within toolkit
+                for func in functions.values():
+                    func_name = _safe_name(func, fallback=func.__class__.__name__)
+                    # Check if function requires confirmation or external execution
+                    # First check function-level settings, then toolkit-level settings
+                    requires_confirmation = getattr(func, "requires_confirmation", None)
+                    external_execution = getattr(func, "external_execution", None)
+
+                    # If not set on function, check toolkit settings
+                    if requires_confirmation is None and hasattr(tool, "requires_confirmation_tools"):
+                        requires_confirmation = func_name in (tool.requires_confirmation_tools or [])
+                    if external_execution is None and hasattr(tool, "external_execution_required_tools"):
+                        external_execution = func_name in (tool.external_execution_required_tools or [])
+
+                    # Get parameters - ensure they're processed if needed
+                    func_params = func.parameters
+                    # If parameters are empty/default and function has entrypoint, try to process it
+                    default_params = {"type": "object", "properties": {}, "required": []}
+                    if func_params == default_params and func.entrypoint and not func.skip_entrypoint_processing:
+                        try:
+                            # Create a copy to avoid modifying the original
+                            func_copy = func.model_copy(deep=False)
+                            func_copy.process_entrypoint(strict=False)
+                            func_params = func_copy.parameters
+                        except Exception:
+                            # If processing fails, use original parameters
+                            pass
+
+                    components.append(
+                        ComponentResponse(
+                            name=func_name,
+                            component_type="tool",
+                            description=_safe_str(getattr(func, "description", None)),
+                            parameters=_maybe_jsonable(func_params),
+                            requires_confirmation=requires_confirmation,
+                            external_execution=external_execution,
+                            metadata={
+                                "class_path": _class_path(func),
+                                "toolkit": toolkit_name,
+                                "has_entrypoint": bool(getattr(func, "entrypoint", None)),
+                            },
+                        )
+                    )
+
+            elif isinstance(tool, Function):
+                func_name = _safe_name(tool, fallback=tool.__class__.__name__)
+                requires_confirmation = getattr(tool, "requires_confirmation", None)
+                external_execution = getattr(tool, "external_execution", None)
+
+                # Get parameters - ensure they're processed if needed
+                func_params = tool.parameters
+                # If parameters are empty/default and function has entrypoint, try to process it
+                default_params = {"type": "object", "properties": {}, "required": []}
+                if func_params == default_params and tool.entrypoint and not tool.skip_entrypoint_processing:
+                    try:
+                        # Create a copy to avoid modifying the original
+                        tool_copy = tool.model_copy(deep=False)
+                        tool_copy.process_entrypoint(strict=False)
+                        func_params = tool_copy.parameters
+                    except Exception:
+                        # If processing fails, use original parameters
+                        pass
+
+                components.append(
+                    ComponentResponse(
+                        name=func_name,
+                        component_type="tool",
+                        description=_safe_str(getattr(tool, "description", None)),
+                        parameters=_maybe_jsonable(func_params),
+                        requires_confirmation=requires_confirmation,
+                        external_execution=external_execution,
+                        metadata={
+                            "class_path": _class_path(tool),
+                            "has_entrypoint": bool(getattr(tool, "entrypoint", None)),
+                        },
+                    )
+                )
+
+            elif callable(tool):
+                call_name = getattr(tool, "__name__", None) or tool.__class__.__name__
+                components.append(
+                    ComponentResponse(
+                        name=str(call_name),
+                        component_type="tool",
+                        description=_safe_str(getattr(tool, "__doc__", None)),
+                        metadata={"class_path": _class_path(tool)},
+                    )
+                )
+
+        # Models
+        for model in getattr(registry, "models", []) or []:
+            model_name = (
+                _safe_str(getattr(model, "id", None))
+                or _safe_str(getattr(model, "name", None))
+                or model.__class__.__name__
+            )
+            components.append(
+                ComponentResponse(
+                    name=model_name,
+                    component_type="model",
+                    description=_safe_str(getattr(model, "description", None)),
+                    metadata={
+                        "class_path": _class_path(model),
+                        "provider": _safe_str(getattr(model, "provider", None)),
+                        "model_id": _safe_str(getattr(model, "id", None)),
+                    },
+                )
+            )
+
+        # Databases
+        for db in getattr(registry, "dbs", []) or []:
+            db_name = (
+                _safe_str(getattr(db, "name", None))
+                or _safe_str(getattr(db, "id", None))
+                or _safe_str(getattr(db, "table_name", None))
+                or db.__class__.__name__
+            )
+            components.append(
+                ComponentResponse(
+                    name=db_name,
+                    component_type="db",
+                    metadata={
+                        "class_path": _class_path(db),
+                        "db_id": _safe_str(getattr(db, "id", None)),
+                        "table_name": _safe_str(getattr(db, "table_name", None)),
+                    },
+                )
+            )
+
+        # Vector databases
+        for vdb in getattr(registry, "vector_dbs", []) or []:
+            vdb_name = (
+                _safe_str(getattr(vdb, "name", None))
+                or _safe_str(getattr(vdb, "id", None))
+                or _safe_str(getattr(vdb, "collection", None))
+                or _safe_str(getattr(vdb, "table_name", None))
+                or vdb.__class__.__name__
+            )
+            components.append(
+                ComponentResponse(
+                    name=vdb_name,
+                    component_type="vector_db",
+                    metadata={
+                        "class_path": _class_path(vdb),
+                        "vector_db_id": _safe_str(getattr(vdb, "id", None)),
+                        "collection": _safe_str(getattr(vdb, "collection", None)),
+                        "table_name": _safe_str(getattr(vdb, "table_name", None)),
+                    },
+                )
+            )
+
+        # Schemas
+        for schema in getattr(registry, "schemas", []) or []:
+            schema_name = schema.__name__
+            meta: Dict[str, Any] = {"class_path": _class_path(schema)}
+            if include_schema:
+                try:
+                    meta["schema"] = schema.model_json_schema() if hasattr(schema, "model_json_schema") else {}
+                except Exception as e:
+                    meta["schema_error"] = str(e)
+
+            components.append(
+                ComponentResponse(
+                    name=schema_name,
+                    component_type="schema",
+                    metadata=meta,
+                )
+            )
+
+        # Stable ordering helps pagination
+        components.sort(key=lambda c: (c.component_type, c.name))
+        return components
+
+    @router.get(
+        "/registry",
+        response_model=PaginatedResponse[ComponentResponse],
+        response_model_exclude_none=True,
+        status_code=200,
+        operation_id="list_registry",
+        summary="List Registry",
+        description="List all components in the registry with optional filtering.",
+    )
+    async def list_registry(
+        component_type: Optional[ComponentType] = Query(None, description="Filter by component type"),
+        name: Optional[str] = Query(None, description="Filter by name (partial match)"),
+        include_schema: bool = Query(False, description="Include JSON schema for schema components"),
+        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
+            components = _get_all_components(include_schema=include_schema)
+
+            if component_type:
+                components = [c for c in components if c.component_type == component_type]
+
+            if name:
+                needle = name.lower().strip()
+                components = [c for c in components if needle in c.name.lower()]
+
+            total_count = len(components)
+            total_pages = (total_count + limit - 1) // limit if limit > 0 else 0
+            start_idx = (page - 1) * limit
+            paginated = components[start_idx : start_idx + limit]
+
+            return PaginatedResponse(
+                data=paginated,
+                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=str(e))
+
+    return router

agno/os/routers/teams/router.py

@@ -13,6 +13,7 @@ from fastapi import (
 )
 from fastapi.responses import JSONResponse, StreamingResponse
 
+from agno.db.base import BaseDb
 from agno.exceptions import InputCheckError, OutputCheckError
 from agno.media import Audio, Image, Video
 from agno.media import File as FileMedia
@@ -35,6 +36,7 @@ from agno.os.utils import (
     process_image,
     process_video,
 )
+from agno.registry import Registry
 from agno.run.team import RunErrorEvent as TeamRunErrorEvent
 from agno.team.remote import RemoteTeam
 from agno.team.team import Team
@@ -111,6 +113,7 @@ async def team_response_streamer(
 def get_team_router(
     os: "AgentOS",
     settings: AgnoAPISettings = AgnoAPISettings(),
+    registry: Optional[Registry] = None,
 ) -> APIRouter:
     """Create the team router with comprehensive OpenAPI documentation."""
     router = APIRouter(
@@ -165,6 +168,7 @@ def get_team_router(
         session_id: Optional[str] = Form(None),
         user_id: Optional[str] = Form(None),
         files: Optional[List[UploadFile]] = File(None),
+        version: Optional[int] = Form(None),
     ):
         kwargs = await get_request_kwargs(request, create_team_run)
 
@@ -194,7 +198,9 @@ def get_team_router(
 
         logger.debug(f"Creating team run: {message=} {session_id=} {monitor=} {user_id=} {team_id=} {files=} {kwargs=}")
 
-        team = get_team_by_id(team_id, os.teams, create_fresh=True)
+        team = get_team_by_id(
+            team_id=team_id, teams=os.teams, db=os.db, version=version, registry=registry, create_fresh=True
+        )
         if team is None:
             raise HTTPException(status_code=404, detail="Team not found")
 
@@ -321,7 +327,7 @@ def get_team_router(
         team_id: str,
         run_id: str,
     ):
-        team = get_team_by_id(team_id, os.teams, create_fresh=True)
+        team = get_team_by_id(team_id=team_id, teams=os.teams, db=os.db, registry=registry, create_fresh=True)
         if team is None:
             raise HTTPException(status_code=404, detail="Team not found")
 
@@ -414,9 +420,6 @@ def get_team_router(
     )
     async def get_teams(request: Request) -> List[TeamResponse]:
         """Return the list of all Teams present in the contextual OS"""
-        if os.teams is None:
-            return []
-
         # Filter teams based on user's scopes (only if authorization is enabled)
         if getattr(request.state, "authorization_enabled", False):
             from agno.os.auth import filter_resources_by_access, get_accessible_resources
@@ -426,9 +429,9 @@ def get_team_router(
             if not accessible_ids:
                 raise HTTPException(status_code=403, detail="Insufficient permissions")
 
-            accessible_teams = filter_resources_by_access(request, os.teams, "teams")
+            accessible_teams = filter_resources_by_access(request, os.teams or [], "teams")
         else:
-            accessible_teams = os.teams
+            accessible_teams = os.teams or []
 
         teams = []
         for team in accessible_teams:
@@ -438,6 +441,15 @@ def get_team_router(
                 team_response = await TeamResponse.from_team(team=team)
                 teams.append(team_response)
 
+        # Also load teams from database
+        if os.db and isinstance(os.db, BaseDb):
+            from agno.team.team import get_teams
+
+            db_teams = get_teams(db=os.db, registry=registry)
+            for db_team in db_teams:
+                team_response = await TeamResponse.from_team(team=db_team)
+                teams.append(team_response)
+
         return teams
 
     @router.get(
@@ -526,7 +538,7 @@ def get_team_router(
         dependencies=[Depends(require_resource_access("teams", "read", "team_id"))],
     )
     async def get_team(team_id: str, request: Request) -> TeamResponse:
-        team = get_team_by_id(team_id, os.teams, create_fresh=True)
+        team = get_team_by_id(team_id=team_id, teams=os.teams, db=os.db, registry=registry, create_fresh=True)
         if team is None:
             raise HTTPException(status_code=404, detail="Team not found")
 

agno/os/routers/teams/schema.py

@@ -65,7 +65,7 @@ class TeamResponse(BaseModel):
             "enable_agentic_knowledge_filters": False,
             # Memory defaults
             "enable_agentic_memory": False,
-            "enable_user_memories": False,
+            "update_memory_on_run": False,
             # Reasoning defaults
             "reasoning": False,
             "reasoning_min_steps": 1,
@@ -137,8 +137,9 @@ class TeamResponse(BaseModel):
             "cache_session": team.cache_session,
         }
 
+        contents_db = getattr(team.knowledge, "contents_db", None) if team.knowledge else None
         knowledge_info = {
-            "db_id": team.knowledge.contents_db.id if team.knowledge and team.knowledge.contents_db else None,
+            "db_id": contents_db.id if contents_db else None,
             "knowledge_table": knowledge_table,
             "enable_agentic_knowledge_filters": team.enable_agentic_knowledge_filters,
             "knowledge_filters": team.knowledge_filters,
@@ -149,9 +150,10 @@ class TeamResponse(BaseModel):
         if team.memory_manager is not None:
             memory_info = {
                 "enable_agentic_memory": team.enable_agentic_memory,
-                "enable_user_memories": team.enable_user_memories,
+                "update_memory_on_run": team.update_memory_on_run,
+                "enable_user_memories": team.enable_user_memories,  # Soon to be deprecated. Use update_memory_on_run
                 "metadata": team.metadata,
-                "memory_table": team.db.memory_table_name if team.db and team.enable_user_memories else None,
+                "memory_table": team.db.memory_table_name if team.db and team.update_memory_on_run else None,
             }
 
             if team.memory_manager.model is not None:

agno/os/routers/traces/traces.py

@@ -22,7 +22,7 @@ from agno.os.schema import (
     ValidationErrorResponse,
 )
 from agno.os.settings import AgnoAPISettings
-from agno.os.utils import get_db, parse_datetime_to_utc
+from agno.os.utils import get_db, timestamp_to_datetime
 from agno.remote.base import RemoteDb
 from agno.utils.log import log_error
 
@@ -159,8 +159,8 @@ def attach_routes(router: APIRouter, dbs: dict[str, list[Union[BaseDb, AsyncBase
             start_time_ms = time_module.time() * 1000
 
             # Convert ISO datetime strings to UTC datetime objects
-            start_time_dt = parse_datetime_to_utc(start_time, "start_time") if start_time else None
-            end_time_dt = parse_datetime_to_utc(end_time, "end_time") if end_time else None
+            start_time_dt = timestamp_to_datetime(start_time, "start_time") if start_time else None
+            end_time_dt = timestamp_to_datetime(end_time, "end_time") if end_time else None
 
             if isinstance(db, AsyncBaseDb):
                 traces, total_count = await db.get_traces(
@@ -484,8 +484,8 @@ def attach_routes(router: APIRouter, dbs: dict[str, list[Union[BaseDb, AsyncBase
             start_time_ms = time_module.time() * 1000
 
             # Convert ISO datetime strings to UTC datetime objects
-            start_time_dt = parse_datetime_to_utc(start_time, "start_time") if start_time else None
-            end_time_dt = parse_datetime_to_utc(end_time, "end_time") if end_time else None
+            start_time_dt = timestamp_to_datetime(start_time, "start_time") if start_time else None
+            end_time_dt = timestamp_to_datetime(end_time, "end_time") if end_time else None
 
             if isinstance(db, AsyncBaseDb):
                 stats_list, total_count = await db.get_trace_stats(

agno/os/routers/workflows/router.py

@@ -14,6 +14,7 @@ from fastapi import (
 from fastapi.responses import JSONResponse, StreamingResponse
 from pydantic import BaseModel
 
+from agno.db.base import BaseDb
 from agno.exceptions import InputCheckError, OutputCheckError
 from agno.os.auth import (
     get_auth_token_from_request,
@@ -61,7 +62,9 @@ async def handle_workflow_via_websocket(websocket: WebSocket, message: dict, os:
             return
 
         # Get workflow from OS
-        workflow = get_workflow_by_id(workflow_id, os.workflows, create_fresh=True)
+        workflow = get_workflow_by_id(
+            workflow_id=workflow_id, workflows=os.workflows, db=os.db, registry=os.registry, create_fresh=True
+        )
         if not workflow:
             await websocket.send_text(json.dumps({"event": "error", "error": f"Workflow {workflow_id} not found"}))
             return
@@ -141,7 +144,9 @@ async def handle_workflow_subscription(websocket: WebSocket, message: dict, os:
         if buffer_status is None:
             # Run not in buffer - check database
             if workflow_id and session_id:
-                workflow = get_workflow_by_id(workflow_id, os.workflows, create_fresh=True)
+                workflow = get_workflow_by_id(
+                    workflow_id=workflow_id, workflows=os.workflows, db=os.db, registry=os.registry, create_fresh=True
+                )
                 if workflow and isinstance(workflow, Workflow):
                     workflow_run = await workflow.aget_run_output(run_id, session_id)
 
@@ -526,9 +531,6 @@ def get_workflow_router(
         },
     )
     async def get_workflows(request: Request) -> List[WorkflowSummaryResponse]:
-        if os.workflows is None:
-            return []
-
         # Filter workflows based on user's scopes (only if authorization is enabled)
         if getattr(request.state, "authorization_enabled", False):
             from agno.os.auth import filter_resources_by_access, get_accessible_resources
@@ -538,11 +540,24 @@ def get_workflow_router(
             if not accessible_ids:
                 raise HTTPException(status_code=403, detail="Insufficient permissions")
 
-            accessible_workflows = filter_resources_by_access(request, os.workflows, "workflows")
+            accessible_workflows = filter_resources_by_access(request, os.workflows or [], "workflows")
         else:
-            accessible_workflows = os.workflows
+            accessible_workflows = os.workflows or []
+
+        workflows: List[WorkflowSummaryResponse] = []
+        if accessible_workflows:
+            for workflow in accessible_workflows:
+                workflows.append(WorkflowSummaryResponse.from_workflow(workflow=workflow))
+
+        if os.db and isinstance(os.db, BaseDb):
+            from agno.workflow.workflow import get_workflows
 
-        return [WorkflowSummaryResponse.from_workflow(workflow) for workflow in accessible_workflows]
+            db_workflows = get_workflows(db=os.db, registry=os.registry)
+            if db_workflows:
+                for db_workflow in db_workflows:
+                    workflows.append(WorkflowSummaryResponse.from_workflow(workflow=db_workflow))
+
+        return workflows
 
     @router.get(
         "/workflows/{workflow_id}",
@@ -571,7 +586,9 @@ def get_workflow_router(
         dependencies=[Depends(require_resource_access("workflows", "read", "workflow_id"))],
     )
     async def get_workflow(workflow_id: str, request: Request) -> WorkflowResponse:
-        workflow = get_workflow_by_id(workflow_id, os.workflows, create_fresh=True)
+        workflow = get_workflow_by_id(
+            workflow_id=workflow_id, workflows=os.workflows, db=os.db, registry=os.registry, create_fresh=True
+        )
         if workflow is None:
             raise HTTPException(status_code=404, detail="Workflow not found")
         if isinstance(workflow, RemoteWorkflow):
@@ -622,6 +639,7 @@ def get_workflow_router(
         stream: bool = Form(True),
         session_id: Optional[str] = Form(None),
         user_id: Optional[str] = Form(None),
+        version: Optional[int] = Form(None),
     ):
         kwargs = await get_request_kwargs(request, create_workflow_run)
 
@@ -650,7 +668,14 @@ def get_workflow_router(
             kwargs["metadata"] = metadata
 
         # Retrieve the workflow by ID
-        workflow = get_workflow_by_id(workflow_id, os.workflows, create_fresh=True)
+        workflow = get_workflow_by_id(
+            workflow_id=workflow_id,
+            workflows=os.workflows,
+            db=os.db,
+            version=version,
+            registry=os.registry,
+            create_fresh=True,
+        )
         if workflow is None:
             raise HTTPException(status_code=404, detail="Workflow not found")
 
@@ -716,7 +741,9 @@ def get_workflow_router(
         dependencies=[Depends(require_resource_access("workflows", "run", "workflow_id"))],
     )
     async def cancel_workflow_run(workflow_id: str, run_id: str):
-        workflow = get_workflow_by_id(workflow_id, os.workflows, create_fresh=True)
+        workflow = get_workflow_by_id(
+            workflow_id=workflow_id, workflows=os.workflows, db=os.db, registry=os.registry, create_fresh=True
+        )
 
         if workflow is None:
             raise HTTPException(status_code=404, detail="Workflow not found")

agno/os/routers/workflows/schema.py

@@ -121,7 +121,7 @@ class WorkflowResponse(BaseModel):
 
     @classmethod
     async def from_workflow(cls, workflow: Workflow) -> "WorkflowResponse":
-        workflow_dict = workflow.to_dict()
+        workflow_dict = workflow.to_dict_for_steps()
         steps = workflow_dict.get("steps")
 
         if steps: