agno 2.2.13__py3-none-any.whl → 2.4.3__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/session/session.py

@@ -6,7 +6,7 @@ from uuid import uuid4
 from fastapi import APIRouter, Body, Depends, HTTPException, Path, Query, Request
 
 from agno.db.base import AsyncBaseDb, BaseDb, SessionType
-from agno.os.auth import get_authentication_dependency
+from agno.os.auth import get_auth_token_from_request, get_authentication_dependency
 from agno.os.schema import (
     AgentSessionDetailSchema,
     BadRequestResponse,
@@ -29,13 +29,14 @@ from agno.os.schema import (
 )
 from agno.os.settings import AgnoAPISettings
 from agno.os.utils import get_db
+from agno.remote.base import RemoteDb
 from agno.session import AgentSession, TeamSession, WorkflowSession
 
 logger = logging.getLogger(__name__)
 
 
 def get_session_router(
-    dbs: dict[str, list[Union[BaseDb, AsyncBaseDb]]], settings: AgnoAPISettings = AgnoAPISettings()
+    dbs: dict[str, list[Union[BaseDb, AsyncBaseDb, RemoteDb]]], settings: AgnoAPISettings = AgnoAPISettings()
 ) -> APIRouter:
     """Create session router with comprehensive OpenAPI documentation for session management endpoints."""
     session_router = APIRouter(
@@ -52,7 +53,7 @@ def get_session_router(
     return attach_routes(router=session_router, dbs=dbs)
 
 
-def attach_routes(router: APIRouter, dbs: dict[str, list[Union[BaseDb, AsyncBaseDb]]]) -> APIRouter:
+def attach_routes(router: APIRouter, dbs: dict[str, list[Union[BaseDb, AsyncBaseDb, RemoteDb]]]) -> APIRouter:
     @router.get(
         "/sessions",
         response_model=PaginatedResponse[SessionSchema],
@@ -64,6 +65,7 @@ def attach_routes(router: APIRouter, dbs: dict[str, list[Union[BaseDb, AsyncBase
             "Supports filtering by session type (agent, team, workflow), component, user, and name. "
             "Sessions represent conversation histories and execution contexts."
         ),
+        response_model_exclude_none=True,
         responses={
             200: {
                 "description": "Sessions retrieved successfully",
@@ -105,8 +107,8 @@ def attach_routes(router: APIRouter, dbs: dict[str, list[Union[BaseDb, AsyncBase
         ),
         user_id: Optional[str] = Query(default=None, description="Filter sessions by user ID"),
         session_name: Optional[str] = Query(default=None, description="Filter sessions by name (partial match)"),
-        limit: Optional[int] = Query(default=20, description="Number of sessions to return per page"),
-        page: Optional[int] = Query(default=1, description="Page number for pagination"),
+        limit: Optional[int] = Query(default=20, description="Number of sessions to return per page", ge=1),
+        page: Optional[int] = Query(default=1, description="Page number for pagination", ge=0),
         sort_by: Optional[str] = Query(default="created_at", description="Field to sort sessions by"),
         sort_order: Optional[SortOrder] = Query(default="desc", description="Sort order (asc or desc)"),
         db_id: Optional[str] = Query(default=None, description="Database ID to query sessions from"),
@@ -117,9 +119,26 @@ def attach_routes(router: APIRouter, dbs: dict[str, list[Union[BaseDb, AsyncBase
         except Exception as e:
             raise HTTPException(status_code=404, detail=f"{e}")
 
-        if hasattr(request.state, "user_id"):
+        if hasattr(request.state, "user_id") and request.state.user_id is not None:
             user_id = request.state.user_id
 
+        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_sessions(
+                session_type=session_type,
+                component_id=component_id,
+                user_id=user_id,
+                session_name=session_name,
+                limit=limit,
+                page=page,
+                sort_by=sort_by,
+                sort_order=sort_order.value if sort_order else None,
+                db_id=db_id,
+                table=table,
+                headers=headers,
+            )
+
         if isinstance(db, AsyncBaseDb):
             db = cast(AsyncBaseDb, db)
             sessions, total_count = await db.get_sessions(
@@ -168,6 +187,7 @@ def attach_routes(router: APIRouter, dbs: dict[str, list[Union[BaseDb, AsyncBase
             "before running any agent/team/workflow interactions. "
             "The session can later be used by providing its session_id in run requests."
         ),
+        response_model_exclude_none=True,
         responses={
             201: {
                 "description": "Session created successfully",
@@ -211,9 +231,26 @@ def attach_routes(router: APIRouter, dbs: dict[str, list[Union[BaseDb, AsyncBase
 
         # Get user_id from request state if available (from auth middleware)
         user_id = create_session_request.user_id
-        if hasattr(request.state, "user_id"):
+        if hasattr(request.state, "user_id") and request.state.user_id is not None:
             user_id = request.state.user_id
 
+        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_session(
+                session_type=session_type,
+                session_id=create_session_request.session_id,
+                session_name=create_session_request.session_name,
+                session_state=create_session_request.session_state,
+                metadata=create_session_request.metadata,
+                user_id=user_id,
+                agent_id=create_session_request.agent_id,
+                team_id=create_session_request.team_id,
+                workflow_id=create_session_request.workflow_id,
+                db_id=db_id,
+                headers=headers,
+            )
+
         # Generate session_id if not provided
         session_id = create_session_request.session_id or str(uuid4())
 
@@ -293,6 +330,7 @@ def attach_routes(router: APIRouter, dbs: dict[str, list[Union[BaseDb, AsyncBase
             "Retrieve detailed information about a specific session including metadata, configuration, "
             "and run history. Response schema varies based on session type (agent, team, or workflow)."
         ),
+        response_model_exclude_none=True,
         responses={
             200: {
                 "description": "Session details retrieved successfully",
@@ -382,9 +420,21 @@ def attach_routes(router: APIRouter, dbs: dict[str, list[Union[BaseDb, AsyncBase
     ) -> Union[AgentSessionDetailSchema, TeamSessionDetailSchema, WorkflowSessionDetailSchema]:
         db = await get_db(dbs, db_id, table)
 
-        if hasattr(request.state, "user_id"):
+        if hasattr(request.state, "user_id") and request.state.user_id is not None:
             user_id = request.state.user_id
 
+        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_session(
+                session_id=session_id,
+                session_type=session_type,
+                user_id=user_id,
+                db_id=db_id,
+                table=table,
+                headers=headers,
+            )
+
         if isinstance(db, AsyncBaseDb):
             db = cast(AsyncBaseDb, db)
             session = await db.get_session(session_id=session_id, session_type=session_type, user_id=user_id)
@@ -413,6 +463,7 @@ def attach_routes(router: APIRouter, dbs: dict[str, list[Union[BaseDb, AsyncBase
             "Runs represent individual interactions or executions within a session. "
             "Response schema varies based on session type."
         ),
+        response_model_exclude_none=True,
         responses={
             200: {
                 "description": "Session runs retrieved successfully",
@@ -538,9 +589,23 @@ def attach_routes(router: APIRouter, dbs: dict[str, list[Union[BaseDb, AsyncBase
     ) -> List[Union[RunSchema, TeamRunSchema, WorkflowRunSchema]]:
         db = await get_db(dbs, db_id, table)
 
-        if hasattr(request.state, "user_id"):
+        if hasattr(request.state, "user_id") and request.state.user_id is not None:
             user_id = request.state.user_id
 
+        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_session_runs(
+                session_id=session_id,
+                session_type=session_type,
+                user_id=user_id,
+                created_after=created_after,
+                created_before=created_before,
+                db_id=db_id,
+                table=table,
+                headers=headers,
+            )
+
         # Use timestamp filters directly (already in epoch format)
         start_timestamp = created_after
         end_timestamp = created_before
@@ -650,12 +715,26 @@ def attach_routes(router: APIRouter, dbs: dict[str, list[Union[BaseDb, AsyncBase
         ),
         user_id: Optional[str] = Query(default=None, description="User ID to query run from"),
         db_id: Optional[str] = Query(default=None, description="Database ID to query run from"),
+        table: Optional[str] = Query(default=None, description="Table to query run from"),
     ) -> Union[RunSchema, TeamRunSchema, WorkflowRunSchema]:
         db = await get_db(dbs, db_id)
 
-        if hasattr(request.state, "user_id"):
+        if hasattr(request.state, "user_id") and request.state.user_id is not None:
             user_id = request.state.user_id
 
+        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_session_run(
+                session_id=session_id,
+                run_id=run_id,
+                session_type=session_type,
+                user_id=user_id,
+                db_id=db_id,
+                table=table,
+                headers=headers,
+            )
+
         if isinstance(db, AsyncBaseDb):
             db = cast(AsyncBaseDb, db)
             session = await db.get_session(
@@ -707,11 +786,19 @@ def attach_routes(router: APIRouter, dbs: dict[str, list[Union[BaseDb, AsyncBase
         },
     )
     async def delete_session(
+        request: Request,
         session_id: str = Path(description="Session ID to delete"),
         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:
         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
+            await db.delete_session(session_id=session_id, db_id=db_id, table=table, headers=headers)
+            return
+
         if isinstance(db, AsyncBaseDb):
             db = cast(AsyncBaseDb, db)
             await db.delete_session(session_id=session_id)
@@ -737,10 +824,8 @@ def attach_routes(router: APIRouter, dbs: dict[str, list[Union[BaseDb, AsyncBase
         },
     )
     async def delete_sessions(
+        http_request: Request,
         request: DeleteSessionRequest,
-        session_type: SessionType = Query(
-            default=SessionType.AGENT, description="Default session type filter", alias="type"
-        ),
         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:
@@ -748,6 +833,19 @@ def attach_routes(router: APIRouter, dbs: dict[str, list[Union[BaseDb, AsyncBase
             raise HTTPException(status_code=400, detail="Session IDs and session types must have the same length")
 
         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
+            await db.delete_sessions(
+                session_ids=request.session_ids,
+                session_types=request.session_types,
+                db_id=db_id,
+                table=table,
+                headers=headers,
+            )
+            return
+
         if isinstance(db, AsyncBaseDb):
             db = cast(AsyncBaseDb, db)
             await db.delete_sessions(session_ids=request.session_ids)
@@ -843,6 +941,7 @@ def attach_routes(router: APIRouter, dbs: dict[str, list[Union[BaseDb, AsyncBase
         },
     )
     async def rename_session(
+        request: Request,
         session_id: str = Path(description="Session ID to rename"),
         session_type: SessionType = Query(
             default=SessionType.AGENT, description="Session type (agent, team, or workflow)", alias="type"
@@ -852,6 +951,19 @@ def attach_routes(router: APIRouter, dbs: dict[str, list[Union[BaseDb, AsyncBase
         table: Optional[str] = Query(default=None, description="Table to use for rename operation"),
     ) -> Union[AgentSessionDetailSchema, TeamSessionDetailSchema, WorkflowSessionDetailSchema]:
         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.rename_session(
+                session_id=session_id,
+                session_name=session_name,
+                session_type=session_type,
+                db_id=db_id,
+                table=table,
+                headers=headers,
+            )
+
         if isinstance(db, AsyncBaseDb):
             db = cast(AsyncBaseDb, db)
             session = await db.rename_session(
@@ -935,12 +1047,29 @@ def attach_routes(router: APIRouter, dbs: dict[str, list[Union[BaseDb, AsyncBase
         update_data: UpdateSessionRequest = Body(description="Session update data"),
         user_id: Optional[str] = Query(default=None, description="User ID"),
         db_id: Optional[str] = Query(default=None, description="Database ID to use for update operation"),
+        table: Optional[str] = Query(default=None, description="Table to use for update operation"),
     ) -> Union[AgentSessionDetailSchema, TeamSessionDetailSchema, WorkflowSessionDetailSchema]:
         db = await get_db(dbs, db_id)
 
-        if hasattr(request.state, "user_id"):
+        if hasattr(request.state, "user_id") and request.state.user_id is not None:
             user_id = request.state.user_id
 
+        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.update_session(
+                session_id=session_id,
+                session_type=session_type,
+                session_name=update_data.session_name,
+                session_state=update_data.session_state,
+                metadata=update_data.metadata,
+                summary=update_data.summary,
+                user_id=user_id,
+                db_id=db_id,
+                table=table,
+                headers=headers,
+            )
+
         # Get the existing session
         if isinstance(db, AsyncBaseDb):
             db = cast(AsyncBaseDb, db)

agno/os/routers/teams/__init__.py

@@ -0,0 +1,3 @@
+from agno.os.routers.teams.router import get_team_router
+
+__all__ = ["get_team_router"]