agno 2.0.3__py3-none-any.whl → 2.0.4__py3-none-any.whl

agno/models/response.py

@@ -29,11 +29,15 @@ class ToolExecution:
     result: Optional[str] = None
     metrics: Optional[Metrics] = None
 
+    # In the case where a tool call creates a run of an agent/team/workflow
+    child_run_id: Optional[str] = None
+
     # If True, the agent will stop executing after this tool call.
     stop_after_tool_call: bool = False
 
     created_at: int = int(time())
 
+    # User control flow requirements
     requires_confirmation: Optional[bool] = None
     confirmed: Optional[bool] = None
     confirmation_note: Optional[str] = None
@@ -66,6 +70,7 @@ class ToolExecution:
             tool_args=data.get("tool_args"),
             tool_call_error=data.get("tool_call_error"),
             result=data.get("result"),
+            child_run_id=data.get("child_run_id"),
             stop_after_tool_call=data.get("stop_after_tool_call", False),
             requires_confirmation=data.get("requires_confirmation"),
             confirmed=data.get("confirmed"),

agno/models/siliconflow/__init__.py

@@ -0,0 +1,5 @@
+from agno.models.siliconflow.siliconflow import Siliconflow
+
+__all__ = [
+    "Siliconflow",
+]

agno/models/siliconflow/siliconflow.py

@@ -0,0 +1,25 @@
+from dataclasses import dataclass
+from os import getenv
+from typing import Optional
+
+from agno.models.openai.like import OpenAILike
+
+
+@dataclass
+class Siliconflow(OpenAILike):
+    """
+    A class for interacting with Siliconflow API.
+
+    Attributes:
+        id (str): The id of the Siliconflow model to use. Default is "Qwen/QwQ-32B".
+        name (str): The name of this chat model instance. Default is "Siliconflow".
+        provider (str): The provider of the model. Default is "Siliconflow".
+        api_key (str): The api key to authorize request to Siliconflow.
+        base_url (str): The base url to which the requests are sent. Defaults to "https://api.siliconflow.cn/v1".
+    """
+
+    id: str = "Qwen/QwQ-32B"
+    name: str = "Siliconflow"
+    provider: str = "Siliconflow"
+    api_key: Optional[str] = getenv("SILICONFLOW_API_KEY")
+    base_url: str = "https://api.siliconflow.com/v1"

agno/os/app.py

@@ -27,8 +27,9 @@ from agno.os.config import (
     SessionDomainConfig,
 )
 from agno.os.interfaces.base import BaseInterface
-from agno.os.router import get_base_router
+from agno.os.router import get_base_router, get_websocket_router
 from agno.os.routers.evals import get_eval_router
+from agno.os.routers.health import get_health_router
 from agno.os.routers.knowledge import get_knowledge_router
 from agno.os.routers.memory import get_memory_router
 from agno.os.routers.metrics import get_metrics_router
@@ -208,6 +209,8 @@ class AgentOS:
 
         # Add routes
         self.fastapi_app.include_router(get_base_router(self, settings=self.settings))
+        self.fastapi_app.include_router(get_websocket_router(self, settings=self.settings))
+        self.fastapi_app.include_router(get_health_router())
 
         for interface in self.interfaces:
             interface_router = interface.get_router()

agno/os/auth.py

@@ -1,7 +1,5 @@
-from typing import Optional
-
-from fastapi import Header, HTTPException
-from fastapi.security import HTTPBearer
+from fastapi import Depends, HTTPException
+from fastapi.security import HTTPAuthorizationCredentials, HTTPBearer
 
 from agno.os.settings import AgnoAPISettings
 
@@ -20,23 +18,16 @@ def get_authentication_dependency(settings: AgnoAPISettings):
         A dependency function that can be used with FastAPI's Depends()
     """
 
-    def auth_dependency(authorization: Optional[str] = Header(None)) -> bool:
+    def auth_dependency(credentials: HTTPAuthorizationCredentials = Depends(security)) -> bool:
         # If no security key is set, skip authentication entirely
         if not settings or not settings.os_security_key:
             return True
 
         # If security is enabled but no authorization header provided, fail
-        if not authorization:
+        if not credentials:
             raise HTTPException(status_code=401, detail="Authorization header required")
 
-        # Check if the authorization header starts with "Bearer "
-        if not authorization.startswith("Bearer "):
-            raise HTTPException(
-                status_code=401, detail="Invalid authorization header format. Expected 'Bearer <token>'"
-            )
-
-        # Extract the token from the authorization header
-        token = authorization[7:]  # Remove "Bearer " prefix
+        token = credentials.credentials
 
         # Verify the token
         if token != settings.os_security_key:
@@ -45,3 +36,22 @@ def get_authentication_dependency(settings: AgnoAPISettings):
         return True
 
     return auth_dependency
+
+
+def validate_websocket_token(token: str, settings: AgnoAPISettings) -> bool:
+    """
+    Validate a bearer token for WebSocket authentication.
+
+    Args:
+        token: The bearer token to validate
+        settings: The API settings containing the security key
+
+    Returns:
+        True if the token is valid or authentication is disabled, False otherwise
+    """
+    # If no security key is set, skip authentication entirely
+    if not settings or not settings.os_security_key:
+        return True
+
+    # Verify the token matches the configured security key
+    return token == settings.os_security_key

agno/os/router.py

@@ -18,13 +18,12 @@ from pydantic import BaseModel
 from agno.agent.agent import Agent
 from agno.media import Audio, Image, Video
 from agno.media import File as FileMedia
-from agno.os.auth import get_authentication_dependency
+from agno.os.auth import get_authentication_dependency, validate_websocket_token
 from agno.os.schema import (
     AgentResponse,
     AgentSummaryResponse,
     BadRequestResponse,
     ConfigResponse,
-    HealthResponse,
     InterfaceResponse,
     InternalServerErrorResponse,
     Model,
@@ -49,7 +48,7 @@ from agno.os.utils import (
 from agno.run.agent import RunErrorEvent, RunOutput, RunOutputEvent
 from agno.run.team import RunErrorEvent as TeamRunErrorEvent
 from agno.run.team import TeamRunOutputEvent
-from agno.run.workflow import WorkflowErrorEvent, WorkflowRunOutputEvent
+from agno.run.workflow import WorkflowErrorEvent, WorkflowRunOutput, WorkflowRunOutputEvent
 from agno.team.team import Team
 from agno.utils.log import log_debug, log_error, log_warning, logger
 from agno.workflow.workflow import Workflow
@@ -110,6 +109,7 @@ class WebSocketManager:
     """Manages WebSocket connections for workflow runs"""
 
     active_connections: Dict[str, WebSocket]  # {run_id: websocket}
+    authenticated_connections: Dict[WebSocket, bool]  # {websocket: is_authenticated}
 
     def __init__(
         self,
@@ -117,22 +117,51 @@ class WebSocketManager:
     ):
         # Store active connections: {run_id: websocket}
         self.active_connections = active_connections or {}
+        # Track authentication state for each websocket
+        self.authenticated_connections = {}
 
-    async def connect(self, websocket: WebSocket):
+    async def connect(self, websocket: WebSocket, requires_auth: bool = True):
         """Accept WebSocket connection"""
         await websocket.accept()
         logger.debug("WebSocket connected")
 
-        # Send connection confirmation
+        # If auth is not required, mark as authenticated immediately
+        self.authenticated_connections[websocket] = not requires_auth
+
+        # Send connection confirmation with auth requirement info
         await websocket.send_text(
             json.dumps(
                 {
                     "event": "connected",
-                    "message": "Connected to workflow events",
+                    "message": (
+                        "Connected to workflow events. Please authenticate to continue."
+                        if requires_auth
+                        else "Connected to workflow events. Authentication not required."
+                    ),
+                    "requires_auth": requires_auth,
                 }
             )
         )
 
+    async def authenticate_websocket(self, websocket: WebSocket):
+        """Mark a WebSocket connection as authenticated"""
+        self.authenticated_connections[websocket] = True
+        logger.debug("WebSocket authenticated")
+
+        # Send authentication confirmation
+        await websocket.send_text(
+            json.dumps(
+                {
+                    "event": "authenticated",
+                    "message": "Authentication successful. You can now send commands.",
+                }
+            )
+        )
+
+    def is_authenticated(self, websocket: WebSocket) -> bool:
+        """Check if a WebSocket connection is authenticated"""
+        return self.authenticated_connections.get(websocket, False)
+
     async def register_workflow_websocket(self, run_id: str, websocket: WebSocket):
         """Register a workflow run with its WebSocket connection"""
         self.active_connections[run_id] = websocket
@@ -141,9 +170,26 @@ class WebSocketManager:
     async def disconnect_by_run_id(self, run_id: str):
         """Remove WebSocket connection by run_id"""
         if run_id in self.active_connections:
+            websocket = self.active_connections[run_id]
             del self.active_connections[run_id]
+            # Clean up authentication state
+            if websocket in self.authenticated_connections:
+                del self.authenticated_connections[websocket]
             logger.debug(f"WebSocket disconnected for run_id: {run_id}")
 
+    async def disconnect_websocket(self, websocket: WebSocket):
+        """Remove WebSocket connection and clean up all associated state"""
+        # Remove from authenticated connections
+        if websocket in self.authenticated_connections:
+            del self.authenticated_connections[websocket]
+
+        # Remove from active connections
+        runs_to_remove = [run_id for run_id, ws in self.active_connections.items() if ws == websocket]
+        for run_id in runs_to_remove:
+            del self.active_connections[run_id]
+
+        logger.debug("WebSocket disconnected and cleaned up")
+
     async def get_websocket_for_run(self, run_id: str) -> Optional[WebSocket]:
         """Get WebSocket connection for a workflow run"""
         return self.active_connections.get(run_id)
@@ -288,7 +334,7 @@ async def handle_workflow_via_websocket(websocket: WebSocket, message: dict, os:
                 session_id = str(uuid4())
 
         # Execute workflow in background with streaming
-        await workflow.arun(
+        workflow_result = await workflow.arun(
             input=user_message,
             session_id=session_id,
             user_id=user_id,
@@ -298,6 +344,10 @@ async def handle_workflow_via_websocket(websocket: WebSocket, message: dict, os:
             websocket=websocket,
         )
 
+        workflow_run_output = cast(WorkflowRunOutput, workflow_result)
+
+        await websocket_manager.register_workflow_websocket(workflow_run_output.run_id, websocket)  # type: ignore
+
     except Exception as e:
         logger.error(f"Error executing workflow via WebSocket: {e}")
         await websocket.send_text(json.dumps({"event": "error", "error": str(e)}))
@@ -334,6 +384,77 @@ async def workflow_response_streamer(
         return
 
 
+def get_websocket_router(
+    os: "AgentOS",
+    settings: AgnoAPISettings = AgnoAPISettings(),
+) -> APIRouter:
+    """
+    Create WebSocket router without HTTP authentication dependencies.
+    WebSocket endpoints handle authentication internally via message-based auth.
+    """
+    ws_router = APIRouter()
+
+    @ws_router.websocket(
+        "/workflows/ws",
+        name="workflow_websocket",
+    )
+    async def workflow_websocket_endpoint(websocket: WebSocket):
+        """WebSocket endpoint for receiving real-time workflow events"""
+        requires_auth = bool(settings.os_security_key)
+        await websocket_manager.connect(websocket, requires_auth=requires_auth)
+
+        try:
+            while True:
+                data = await websocket.receive_text()
+                message = json.loads(data)
+                action = message.get("action")
+
+                # Handle authentication first
+                if action == "authenticate":
+                    token = message.get("token")
+                    if not token:
+                        await websocket.send_text(json.dumps({"event": "auth_error", "error": "Token is required"}))
+                        continue
+
+                    if validate_websocket_token(token, settings):
+                        await websocket_manager.authenticate_websocket(websocket)
+                    else:
+                        await websocket.send_text(json.dumps({"event": "auth_error", "error": "Invalid token"}))
+                        continue
+
+                # Check authentication for all other actions (only when required)
+                elif requires_auth and not websocket_manager.is_authenticated(websocket):
+                    await websocket.send_text(
+                        json.dumps(
+                            {
+                                "event": "auth_required",
+                                "error": "Authentication required. Send authenticate action with valid token.",
+                            }
+                        )
+                    )
+                    continue
+
+                # Handle authenticated actions
+                elif action == "ping":
+                    await websocket.send_text(json.dumps({"event": "pong"}))
+
+                elif action == "start-workflow":
+                    # Handle workflow execution directly via WebSocket
+                    await handle_workflow_via_websocket(websocket, message, os)
+
+                else:
+                    await websocket.send_text(json.dumps({"event": "error", "error": f"Unknown action: {action}"}))
+
+        except Exception as e:
+            if "1012" not in str(e):
+                logger.error(f"WebSocket error: {e}")
+        finally:
+            # Clean up the websocket connection
+            await websocket_manager.disconnect_websocket(websocket)
+
+    return ws_router
+
+
 def get_base_router(
     os: "AgentOS",
     settings: AgnoAPISettings = AgnoAPISettings(),
@@ -346,7 +467,6 @@ def get_base_router(
     - Agent management and execution
     - Team collaboration and coordination
     - Workflow automation and orchestration
-    - Real-time WebSocket communications
 
     All endpoints include detailed documentation, examples, and proper error handling.
     """
@@ -362,24 +482,6 @@ def get_base_router(
     )
 
     # -- Main Routes ---
-
-    @router.get(
-        "/health",
-        tags=["Core"],
-        operation_id="health_check",
-        summary="Health Check",
-        description="Check the health status of the AgentOS API. Returns a simple status indicator.",
-        response_model=HealthResponse,
-        responses={
-            200: {
-                "description": "API is healthy and operational",
-                "content": {"application/json": {"example": {"status": "ok"}}},
-            }
-        },
-    )
-    async def health_check() -> HealthResponse:
-        return HealthResponse(status="ok")
-
     @router.get(
         "/config",
         response_model=ConfigResponse,
@@ -1228,35 +1330,6 @@ def get_base_router(
 
     # -- Workflow routes ---
 
-    @router.websocket(
-        "/workflows/ws",
-        name="workflow_websocket",
-    )
-    async def workflow_websocket_endpoint(websocket: WebSocket):
-        """WebSocket endpoint for receiving real-time workflow events"""
-        await websocket_manager.connect(websocket)
-
-        try:
-            while True:
-                data = await websocket.receive_text()
-                message = json.loads(data)
-                action = message.get("action")
-
-                if action == "ping":
-                    await websocket.send_text(json.dumps({"event": "pong"}))
-
-                elif action == "start-workflow":
-                    # Handle workflow execution directly via WebSocket
-                    await handle_workflow_via_websocket(websocket, message, os)
-        except Exception as e:
-            if "1012" not in str(e):
-                logger.error(f"WebSocket error: {e}")
-        finally:
-            # Clean up any run_ids associated with this websocket
-            runs_to_remove = [run_id for run_id, ws in websocket_manager.active_connections.items() if ws == websocket]
-            for run_id in runs_to_remove:
-                await websocket_manager.disconnect_by_run_id(run_id)
-
     @router.get(
         "/workflows",
         response_model=List[WorkflowSummaryResponse],

agno/os/routers/evals/utils.py

@@ -35,7 +35,7 @@ async def run_accuracy_eval(
         name=eval_run_input.name,
     )
 
-    result = accuracy_eval.run(print_results=False, print_summary=False)
+    result = await accuracy_eval.arun(print_results=False, print_summary=False)
     if not result:
         raise HTTPException(status_code=500, detail="Failed to run accuracy evaluation")
 
@@ -60,16 +60,16 @@ async def run_performance_eval(
     """Run a performance evaluation for the given agent or team"""
     if agent:
 
-        def run_component():  # type: ignore
-            return agent.run(eval_run_input.input)
+        async def run_component():  # type: ignore
+            return await agent.arun(eval_run_input.input)
 
         model_id = agent.model.id if agent and agent.model else None
         model_provider = agent.model.provider if agent and agent.model else None
 
     elif team:
 
-        def run_component():
-            return team.run(eval_run_input.input)
+        async def run_component():
+            return await team.arun(eval_run_input.input)
 
         model_id = team.model.id if team and team.model else None
         model_provider = team.model.provider if team and team.model else None
@@ -85,7 +85,7 @@ async def run_performance_eval(
         model_id=model_id,
         model_provider=model_provider,
     )
-    result = performance_eval.run(print_results=False, print_summary=False)
+    result = await performance_eval.arun(print_results=False, print_summary=False)
     if not result:
         raise HTTPException(status_code=500, detail="Failed to run performance evaluation")
 
@@ -119,7 +119,7 @@ async def run_reliability_eval(
         raise HTTPException(status_code=400, detail="expected_tool_calls is required for reliability evaluations")
 
     if agent:
-        agent_response = agent.run(eval_run_input.input)
+        agent_response = await agent.arun(eval_run_input.input)
         reliability_eval = ReliabilityEval(
             db=db,
             name=eval_run_input.name,
@@ -130,7 +130,7 @@ async def run_reliability_eval(
         model_provider = agent.model.provider if agent and agent.model else None
 
     elif team:
-        team_response = team.run(eval_run_input.input)
+        team_response = await team.arun(eval_run_input.input)
         reliability_eval = ReliabilityEval(
             db=db,
             name=eval_run_input.name,
@@ -140,7 +140,7 @@ async def run_reliability_eval(
         model_id = team.model.id if team and team.model else None
         model_provider = team.model.provider if team and team.model else None
 
-    result = reliability_eval.run(print_results=False)
+    result = await reliability_eval.arun(print_results=False)
     if not result:
         raise HTTPException(status_code=500, detail="Failed to run reliability evaluation")
 

agno/os/routers/health.py

@@ -0,0 +1,26 @@
+from fastapi import APIRouter
+
+from agno.os.schema import HealthResponse
+
+
+def get_health_router() -> APIRouter:
+    router = APIRouter(tags=["Health"])
+
+    @router.get(
+        "/health",
+        tags=["Core"],
+        operation_id="health_check",
+        summary="Health Check",
+        description="Check the health status of the AgentOS API. Returns a simple status indicator.",
+        response_model=HealthResponse,
+        responses={
+            200: {
+                "description": "API is healthy and operational",
+                "content": {"application/json": {"example": {"status": "ok"}}},
+            }
+        },
+    )
+    async def health_check() -> HealthResponse:
+        return HealthResponse(status="ok")
+
+    return router

agno/os/routers/knowledge/knowledge.py

@@ -2,10 +2,10 @@ import json
 import logging
 import math
 from typing import Dict, List, Optional
-from uuid import uuid4
 
 from fastapi import APIRouter, BackgroundTasks, Depends, File, Form, HTTPException, Path, Query, UploadFile
 
+from agno.db.utils import generate_deterministic_id
 from agno.knowledge.content import Content, FileData
 from agno.knowledge.knowledge import Knowledge
 from agno.knowledge.reader import ReaderFactory
@@ -102,8 +102,7 @@ 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)
-        content_id = str(uuid4())
-        log_info(f"Adding content: {name}, {description}, {url}, {metadata} with ID: {content_id}")
+        log_info(f"Adding content: {name}, {description}, {url}, {metadata}")
 
         parsed_metadata = None
         if metadata:
@@ -166,10 +165,14 @@ def attach_routes(router: APIRouter, knowledge_instances: List[Knowledge]) -> AP
             file_data=file_data,
             size=file.size if file else None if text_content else None,
         )
-        background_tasks.add_task(process_content, knowledge, content_id, content, reader_id, chunker)
+        content_hash = knowledge._build_content_hash(content)
+        content.content_hash = content_hash
+        content.id = generate_deterministic_id(content_hash)
+
+        background_tasks.add_task(process_content, knowledge, content, reader_id, chunker)
 
         response = ContentResponseSchema(
-            id=content_id,
+            id=content.id,
             name=name,
             description=description,
             metadata=parsed_metadata,
@@ -802,15 +805,13 @@ def attach_routes(router: APIRouter, knowledge_instances: List[Knowledge]) -> AP
 
 async def process_content(
     knowledge: Knowledge,
-    content_id: str,
     content: Content,
     reader_id: Optional[str] = None,
     chunker: Optional[str] = None,
 ):
     """Background task to process the content"""
-    log_info(f"Processing content {content_id}")
+
     try:
-        content.id = content_id
         if reader_id:
             reader = None
             if knowledge.readers and reader_id in knowledge.readers:
@@ -834,16 +835,15 @@ async def process_content(
 
         log_debug(f"Using reader: {content.reader.__class__.__name__}")
         await knowledge._load_content(content, upsert=False, skip_if_exists=True)
-        log_info(f"Content {content_id} processed successfully")
+        log_info(f"Content {content.id} processed successfully")
     except Exception as e:
-        log_info(f"Error processing content {content_id}: {e}")
+        log_info(f"Error processing content: {e}")
         # Mark content as failed in the contents DB
         try:
             from agno.knowledge.content import ContentStatus as KnowledgeContentStatus
 
             content.status = KnowledgeContentStatus.FAILED
             content.status_message = str(e)
-            content.id = content_id
             knowledge.patch_content(content)
         except Exception:
             # Swallow any secondary errors to avoid crashing the background task

agno/os/routers/session/session.py

@@ -222,7 +222,9 @@ def attach_routes(router: APIRouter, dbs: dict[str, BaseDb]) -> APIRouter:
         db = get_db(dbs, db_id)
         session = db.get_session(session_id=session_id, session_type=session_type)
         if not session:
-            raise HTTPException(status_code=404, detail=f"Session with id '{session_id}' not found")
+            raise HTTPException(
+                status_code=404, detail=f"{session_type.value.title()} Session with id '{session_id}' not found"
+            )
 
         if session_type == SessionType.AGENT:
             return AgentSessionDetailSchema.from_session(session)  # type: ignore
@@ -233,7 +235,7 @@ def attach_routes(router: APIRouter, dbs: dict[str, BaseDb]) -> APIRouter:
 
     @router.get(
         "/sessions/{session_id}/runs",
-        response_model=Union[List[RunSchema], List[TeamRunSchema], List[WorkflowRunSchema]],
+        response_model=List[Union[RunSchema, TeamRunSchema, WorkflowRunSchema]],
         status_code=200,
         operation_id="get_session_runs",
         summary="Get Session Runs",
@@ -251,7 +253,8 @@ def attach_routes(router: APIRouter, dbs: dict[str, BaseDb]) -> APIRouter:
                                 "summary": "Example completed run",
                                 "value": {
                                     "run_id": "fcdf50f0-7c32-4593-b2ef-68a558774340",
-                                    "agent_session_id": "80056af0-c7a5-4d69-b6a2-c3eba9f040e0",
+                                    "parent_run_id": "80056af0-c7a5-4d69-b6a2-c3eba9f040e0",
+                                    "agent_id": "basic-agent",
                                     "user_id": "",
                                     "run_input": "Which tools do you have access to?",
                                     "content": "I don't have access to external tools or the internet. However, I can assist you with a wide range of topics by providing information, answering questions, and offering suggestions based on the knowledge I've been trained on. If there's anything specific you need help with, feel free to ask!",
@@ -351,7 +354,7 @@ def attach_routes(router: APIRouter, dbs: dict[str, BaseDb]) -> APIRouter:
             default=SessionType.AGENT, description="Session type (agent, team, or workflow)", alias="type"
         ),
         db_id: Optional[str] = Query(default=None, description="Database ID to query runs from"),
-    ) -> Union[List[RunSchema], List[TeamRunSchema], List[WorkflowRunSchema]]:
+    ) -> List[Union[RunSchema, TeamRunSchema, WorkflowRunSchema]]:
         db = get_db(dbs, db_id)
         session = db.get_session(session_id=session_id, session_type=session_type, deserialize=False)
         if not session:
@@ -365,13 +368,26 @@ def attach_routes(router: APIRouter, dbs: dict[str, BaseDb]) -> APIRouter:
             return [RunSchema.from_dict(run) for run in runs]
 
         elif session_type == SessionType.TEAM:
-            return [TeamRunSchema.from_dict(run) for run in runs]
+            run_responses: List[Union[RunSchema, TeamRunSchema, WorkflowRunSchema]] = []
+            for run in runs:
+                if run.get("agent_id") is not None:
+                    run_responses.append(RunSchema.from_dict(run))
+                elif run.get("team_id") is not None:
+                    run_responses.append(TeamRunSchema.from_dict(run))
+            return run_responses
 
         elif session_type == SessionType.WORKFLOW:
-            return [WorkflowRunSchema.from_dict(run) for run in runs]
-
+            run_responses: List[Union[RunSchema, TeamRunSchema, WorkflowRunSchema]] = []  # type: ignore
+            for run in runs:
+                if run.get("workflow_id") is not None:
+                    run_responses.append(WorkflowRunSchema.from_dict(run))
+                elif run.get("team_id") is not None:
+                    run_responses.append(TeamRunSchema.from_dict(run))
+                else:
+                    run_responses.append(RunSchema.from_dict(run))
+            return run_responses
         else:
-            return [RunSchema.from_dict(run) for run in runs]
+            raise HTTPException(status_code=400, detail=f"Invalid session type: {session_type}")
 
     @router.delete(
         "/sessions/{session_id}",