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

agno/models/message.py

@@ -121,6 +121,115 @@ class Message(BaseModel):
 
     @classmethod
     def from_dict(cls, data: Dict[str, Any]) -> "Message":
+        # Handle image reconstruction properly
+        if "images" in data and data["images"]:
+            reconstructed_images = []
+            for i, img_data in enumerate(data["images"]):
+                if isinstance(img_data, dict):
+                    # If content is base64, decode it back to bytes
+                    if "content" in img_data and isinstance(img_data["content"], str):
+                        reconstructed_images.append(
+                            Image.from_base64(
+                                img_data["content"],
+                                id=img_data.get("id"),
+                                mime_type=img_data.get("mime_type"),
+                                format=img_data.get("format"),
+                            )
+                        )
+                    else:
+                        # Regular image (filepath/url)
+                        reconstructed_images.append(Image(**img_data))
+                else:
+                    reconstructed_images.append(img_data)
+            data["images"] = reconstructed_images
+
+        # Handle audio reconstruction properly
+        if "audio" in data and data["audio"]:
+            reconstructed_audio = []
+            for i, aud_data in enumerate(data["audio"]):
+                if isinstance(aud_data, dict):
+                    # If content is base64, decode it back to bytes
+                    if "content" in aud_data and isinstance(aud_data["content"], str):
+                        reconstructed_audio.append(
+                            Audio.from_base64(
+                                aud_data["content"],
+                                id=aud_data.get("id"),
+                                mime_type=aud_data.get("mime_type"),
+                                transcript=aud_data.get("transcript"),
+                                expires_at=aud_data.get("expires_at"),
+                                sample_rate=aud_data.get("sample_rate", 24000),
+                                channels=aud_data.get("channels", 1),
+                            )
+                        )
+                    else:
+                        reconstructed_audio.append(Audio(**aud_data))
+                else:
+                    reconstructed_audio.append(aud_data)
+            data["audio"] = reconstructed_audio
+
+        # Handle video reconstruction properly
+        if "videos" in data and data["videos"]:
+            reconstructed_videos = []
+            for i, vid_data in enumerate(data["videos"]):
+                if isinstance(vid_data, dict):
+                    # If content is base64, decode it back to bytes
+                    if "content" in vid_data and isinstance(vid_data["content"], str):
+                        reconstructed_videos.append(
+                            Video.from_base64(
+                                vid_data["content"],
+                                id=vid_data.get("id"),
+                                mime_type=vid_data.get("mime_type"),
+                                format=vid_data.get("format"),
+                            )
+                        )
+                    else:
+                        reconstructed_videos.append(Video(**vid_data))
+                else:
+                    reconstructed_videos.append(vid_data)
+            data["videos"] = reconstructed_videos
+
+        if "audio_output" in data and data["audio_output"]:
+            aud_data = data["audio_output"]
+            if isinstance(aud_data, dict):
+                if "content" in aud_data and isinstance(aud_data["content"], str):
+                    data["audio_output"] = Audio.from_base64(
+                        aud_data["content"],
+                        id=aud_data.get("id"),
+                        mime_type=aud_data.get("mime_type"),
+                        transcript=aud_data.get("transcript"),
+                        expires_at=aud_data.get("expires_at"),
+                        sample_rate=aud_data.get("sample_rate", 24000),
+                        channels=aud_data.get("channels", 1),
+                    )
+                else:
+                    data["audio_output"] = Audio(**aud_data)
+
+        if "image_output" in data and data["image_output"]:
+            img_data = data["image_output"]
+            if isinstance(img_data, dict):
+                if "content" in img_data and isinstance(img_data["content"], str):
+                    data["image_output"] = Image.from_base64(
+                        img_data["content"],
+                        id=img_data.get("id"),
+                        mime_type=img_data.get("mime_type"),
+                        format=img_data.get("format"),
+                    )
+                else:
+                    data["image_output"] = Image(**img_data)
+
+        if "video_output" in data and data["video_output"]:
+            vid_data = data["video_output"]
+            if isinstance(vid_data, dict):
+                if "content" in vid_data and isinstance(vid_data["content"], str):
+                    data["video_output"] = Video.from_base64(
+                        vid_data["content"],
+                        id=vid_data.get("id"),
+                        mime_type=vid_data.get("mime_type"),
+                        format=vid_data.get("format"),
+                    )
+                else:
+                    data["video_output"] = Video(**vid_data)
+
         return cls(**data)
 
     def to_dict(self) -> Dict[str, Any]:

agno/models/openai/chat.py

@@ -70,6 +70,7 @@ class OpenAIChat(Model):
     service_tier: Optional[str] = None  # "auto" | "default" | "flex" | "priority", defaults to "auto" when not set
     extra_headers: Optional[Any] = None
     extra_query: Optional[Any] = None
+    extra_body: Optional[Any] = None
     request_params: Optional[Dict[str, Any]] = None
     role_map: Optional[Dict[str, str]] = None
 
@@ -191,6 +192,7 @@ class OpenAIChat(Model):
             "top_p": self.top_p,
             "extra_headers": self.extra_headers,
             "extra_query": self.extra_query,
+            "extra_body": self.extra_body,
             "metadata": self.metadata,
             "service_tier": self.service_tier,
         }
@@ -270,6 +272,7 @@ class OpenAIChat(Model):
                 "user": self.user,
                 "extra_headers": self.extra_headers,
                 "extra_query": self.extra_query,
+                "extra_body": self.extra_body,
                 "service_tier": self.service_tier,
             }
         )

agno/models/openai/responses.py

@@ -56,6 +56,9 @@ class OpenAIResponses(Model):
     truncation: Optional[Literal["auto", "disabled"]] = None
     user: Optional[str] = None
     service_tier: Optional[Literal["auto", "default", "flex", "priority"]] = None
+    extra_headers: Optional[Any] = None
+    extra_query: Optional[Any] = None
+    extra_body: Optional[Any] = None
     request_params: Optional[Dict[str, Any]] = None
 
     # Client parameters
@@ -202,6 +205,9 @@ class OpenAIResponses(Model):
             "truncation": self.truncation,
             "user": self.user,
             "service_tier": self.service_tier,
+            "extra_headers": self.extra_headers,
+            "extra_query": self.extra_query,
+            "extra_body": self.extra_body,
         }
         # Populate the reasoning parameter
         base_params = self._set_reasoning_request_param(base_params)
@@ -1082,4 +1088,10 @@ class OpenAIResponses(Model):
         metrics.output_tokens = response_usage.output_tokens or 0
         metrics.total_tokens = response_usage.total_tokens or 0
 
+        if input_tokens_details := response_usage.input_tokens_details:
+            metrics.cache_read_tokens = input_tokens_details.cached_tokens
+
+        if output_tokens_details := response_usage.output_tokens_details:
+            metrics.reasoning_tokens = output_tokens_details.reasoning_tokens
+
         return metrics

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

@@ -1,11 +1,12 @@
 from contextlib import asynccontextmanager
 from functools import partial
 from os import getenv
-from typing import Any, Dict, List, Optional, Union
+from typing import Any, Dict, List, Optional, Set, Union
 from uuid import uuid4
 
-from fastapi import FastAPI, HTTPException
+from fastapi import APIRouter, FastAPI, HTTPException
 from fastapi.responses import JSONResponse
+from fastapi.routing import APIRoute
 from rich import box
 from rich.panel import Panel
 from starlette.middleware.cors import CORSMiddleware
@@ -27,15 +28,18 @@ 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.home import get_home_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
 from agno.os.routers.session import get_session_router
 from agno.os.settings import AgnoAPISettings
-from agno.os.utils import generate_id
 from agno.team.team import Team
+from agno.utils.log import logger
+from agno.utils.string import generate_id, generate_id_from_name
 from agno.workflow.workflow import Workflow
 
 
@@ -69,8 +73,30 @@ class AgentOS:
         fastapi_app: Optional[FastAPI] = None,
         lifespan: Optional[Any] = None,
         enable_mcp: bool = False,
+        replace_routes: bool = True,
         telemetry: bool = True,
     ):
+        """Initialize AgentOS.
+
+        Args:
+            os_id: Unique identifier for this AgentOS instance
+            name: Name of the AgentOS instance
+            description: Description of the AgentOS instance
+            version: Version of the AgentOS instance
+            agents: List of agents to include in the OS
+            teams: List of teams to include in the OS
+            workflows: List of workflows to include in the OS
+            interfaces: List of interfaces to include in the OS
+            config: Configuration file path or AgentOSConfig instance
+            settings: API settings for the OS
+            fastapi_app: Optional custom FastAPI app to use instead of creating a new one
+            lifespan: Optional lifespan context manager for the FastAPI app
+            enable_mcp: Whether to enable MCP (Model Context Protocol)
+            replace_routes: If False and using a custom fastapi_app, skip AgentOS routes that
+                          conflict with existing routes, preferring the user's custom routes.
+                          If True (default), AgentOS routes will override conflicting custom routes.
+            telemetry: Whether to enable telemetry
+        """
         if not agents and not workflows and not teams:
             raise ValueError("Either agents, teams or workflows must be provided.")
 
@@ -91,11 +117,13 @@ class AgentOS:
 
         self.interfaces = interfaces or []
 
-        self.os_id: Optional[str] = os_id
+        self.os_id = os_id
         self.name = name
         self.version = version
         self.description = description
 
+        self.replace_routes = replace_routes
+
         self.telemetry = telemetry
 
         self.enable_mcp = enable_mcp
@@ -145,7 +173,10 @@ class AgentOS:
             for workflow in self.workflows:
                 # TODO: track MCP tools in workflow members
                 if not workflow.id:
-                    workflow.id = generate_id(workflow.name)
+                    workflow.id = generate_id_from_name(workflow.name)
+
+        if not self.os_id:
+            self.os_id = generate_id(self.name) if self.name else str(uuid4())
 
         if self.telemetry:
             from agno.api.os import OSLaunch, log_os_telemetry
@@ -206,16 +237,29 @@ class AgentOS:
             else:
                 self.fastapi_app = self._make_app(lifespan=self.lifespan)
 
-        # Add routes
-        self.fastapi_app.include_router(get_base_router(self, settings=self.settings))
+        # Add routes with conflict detection
+        self._add_router(get_base_router(self, settings=self.settings))
+        self._add_router(get_websocket_router(self, settings=self.settings))
+        self._add_router(get_health_router())
+        self._add_router(get_home_router(self))
 
         for interface in self.interfaces:
             interface_router = interface.get_router()
-            self.fastapi_app.include_router(interface_router)
+            self._add_router(interface_router)
 
         self._auto_discover_databases()
         self._auto_discover_knowledge_instances()
-        self._setup_routers()
+
+        routers = [
+            get_session_router(dbs=self.dbs),
+            get_memory_router(dbs=self.dbs),
+            get_eval_router(dbs=self.dbs, agents=self.agents, teams=self.teams),
+            get_metrics_router(dbs=self.dbs),
+            get_knowledge_router(knowledge_instances=self.knowledge_instances),
+        ]
+
+        for router in routers:
+            self._add_router(router)
 
         # Mount MCP if needed
         if self.enable_mcp and self.mcp_app:
@@ -263,6 +307,94 @@ class AgentOS:
 
         return app.routes
 
+    def _get_existing_route_paths(self) -> Dict[str, List[str]]:
+        """Get all existing route paths and methods from the FastAPI app.
+
+        Returns:
+            Dict[str, List[str]]: Dictionary mapping paths to list of HTTP methods
+        """
+        if not self.fastapi_app:
+            return {}
+
+        existing_paths: Dict[str, Any] = {}
+        for route in self.fastapi_app.routes:
+            if isinstance(route, APIRoute):
+                path = route.path
+                methods = list(route.methods) if route.methods else []
+                if path in existing_paths:
+                    existing_paths[path].extend(methods)
+                else:
+                    existing_paths[path] = methods
+        return existing_paths
+
+    def _add_router(self, router: APIRouter) -> None:
+        """Add a router to the FastAPI app, avoiding route conflicts.
+
+        Args:
+            router: The APIRouter to add
+        """
+        if not self.fastapi_app:
+            return
+
+        # Get existing routes
+        existing_paths = self._get_existing_route_paths()
+
+        # Check for conflicts
+        conflicts = []
+        conflicting_routes = []
+
+        for route in router.routes:
+            if isinstance(route, APIRoute):
+                full_path = route.path
+                route_methods = list(route.methods) if route.methods else []
+
+                if full_path in existing_paths:
+                    conflicting_methods: Set[str] = set(route_methods) & set(existing_paths[full_path])
+                    if conflicting_methods:
+                        conflicts.append({"path": full_path, "methods": list(conflicting_methods), "route": route})
+                        conflicting_routes.append(route)
+
+        if conflicts and self._app_set:
+            if self.replace_routes:
+                # Log warnings but still add all routes (AgentOS routes will override)
+                for conflict in conflicts:
+                    methods_str = ", ".join(conflict["methods"])  # type: ignore
+                    logger.warning(
+                        f"Route conflict detected: {methods_str} {conflict['path']} - "
+                        f"AgentOS route will override existing custom route"
+                    )
+
+                # Remove conflicting routes
+                for route in self.fastapi_app.routes:
+                    for conflict in conflicts:
+                        if isinstance(route, APIRoute):
+                            if route.path == conflict["path"] and list(route.methods) == list(conflict["methods"]):
+                                self.fastapi_app.routes.pop(self.fastapi_app.routes.index(route))
+
+                self.fastapi_app.include_router(router)
+
+            else:
+                # Skip conflicting AgentOS routes, prefer user's existing routes
+                for conflict in conflicts:
+                    methods_str = ", ".join(conflict["methods"])  # type: ignore
+                    logger.debug(
+                        f"Skipping conflicting AgentOS route: {methods_str} {conflict['path']} - "
+                        f"Using existing custom route instead"
+                    )
+
+                # Create a new router without the conflicting routes
+                filtered_router = APIRouter()
+                for route in router.routes:
+                    if route not in conflicting_routes:
+                        filtered_router.routes.append(route)
+
+                # Use the filtered router if it has any routes left
+                if filtered_router.routes:
+                    self.fastapi_app.include_router(filtered_router)
+        else:
+            # No conflicts, add router normally
+            self.fastapi_app.include_router(router)
+
     def _get_telemetry_data(self) -> Dict[str, Any]:
         """Get the telemetry data for the OS"""
         return {
@@ -290,18 +422,25 @@ class AgentOS:
     def _auto_discover_databases(self) -> None:
         """Auto-discover the databases used by all contextual agents, teams and workflows."""
         dbs = {}
+        knowledge_dbs = {}  # Track databases specifically used for knowledge
 
         for agent in self.agents or []:
             if agent.db:
                 dbs[agent.db.id] = agent.db
             if agent.knowledge and agent.knowledge.contents_db:
-                dbs[agent.knowledge.contents_db.id] = agent.knowledge.contents_db
+                knowledge_dbs[agent.knowledge.contents_db.id] = agent.knowledge.contents_db
+                # Also add to general dbs if it's used for both purposes
+                if agent.knowledge.contents_db.id not in dbs:
+                    dbs[agent.knowledge.contents_db.id] = agent.knowledge.contents_db
 
         for team in self.teams or []:
             if team.db:
                 dbs[team.db.id] = team.db
             if team.knowledge and team.knowledge.contents_db:
-                dbs[team.knowledge.contents_db.id] = team.knowledge.contents_db
+                knowledge_dbs[team.knowledge.contents_db.id] = team.knowledge.contents_db
+                # Also add to general dbs if it's used for both purposes
+                if team.knowledge.contents_db.id not in dbs:
+                    dbs[team.knowledge.contents_db.id] = team.knowledge.contents_db
 
         for workflow in self.workflows or []:
             if workflow.db:
@@ -314,6 +453,7 @@ class AgentOS:
                 dbs[interface.team.db.id] = interface.team.db
 
         self.dbs = dbs
+        self.knowledge_dbs = knowledge_dbs
 
     def _auto_discover_knowledge_instances(self) -> None:
         """Auto-discover the knowledge instances used by all contextual agents, teams and workflows."""
@@ -378,16 +518,17 @@ class AgentOS:
         if knowledge_config.dbs is None:
             knowledge_config.dbs = []
 
-        multiple_dbs: bool = len(self.dbs.keys()) > 1
+        multiple_knowledge_dbs: bool = len(self.knowledge_dbs.keys()) > 1
         dbs_with_specific_config = [db.db_id for db in knowledge_config.dbs]
 
-        for db_id in self.dbs.keys():
+        # Only add databases that are actually used for knowledge contents
+        for db_id in self.knowledge_dbs.keys():
             if db_id not in dbs_with_specific_config:
                 knowledge_config.dbs.append(
                     DatabaseConfig(
                         db_id=db_id,
                         domain_config=KnowledgeDomainConfig(
-                            display_name="Knowledge" if not multiple_dbs else "Knowledge in database " + db_id
+                            display_name="Knowledge" if not multiple_knowledge_dbs else "Knowledge in database " + db_id
                         ),
                     )
                 )
@@ -438,29 +579,6 @@ class AgentOS:
 
         return evals_config
 
-    def _setup_routers(self) -> None:
-        """Add all routers to the FastAPI app."""
-        if not self.dbs or not self.fastapi_app:
-            return
-
-        routers = [
-            get_session_router(dbs=self.dbs),
-            get_memory_router(dbs=self.dbs),
-            get_eval_router(dbs=self.dbs, agents=self.agents, teams=self.teams),
-            get_metrics_router(dbs=self.dbs),
-            get_knowledge_router(knowledge_instances=self.knowledge_instances),
-        ]
-
-        for router in routers:
-            self.fastapi_app.include_router(router)
-
-    def set_os_id(self) -> str:
-        # If os_id is already set, keep it instead of overriding with UUID
-        if self.os_id is None:
-            self.os_id = str(uuid4())
-
-        return self.os_id
-
     def serve(
         self,
         app: Union[str, FastAPI],
@@ -482,13 +600,18 @@ class AgentOS:
         from rich.align import Align
         from rich.console import Console, Group
 
-        aligned_endpoint = Align.center(f"[bold cyan]{public_endpoint}[/bold cyan]")
-        connection_endpoint = f"\n\n[bold dark_orange]Running on:[/bold dark_orange] http://{host}:{port}"
+        panel_group = []
+        panel_group.append(Align.center(f"[bold cyan]{public_endpoint}[/bold cyan]"))
+        panel_group.append(
+            Align.center(f"\n\n[bold dark_orange]OS running on:[/bold dark_orange] http://{host}:{port}")
+        )
+        if bool(self.settings.os_security_key):
+            panel_group.append(Align.center("\n\n[bold chartreuse3]:lock: Security Enabled[/bold chartreuse3]"))
 
         console = Console()
         console.print(
             Panel(
-                Group(aligned_endpoint, connection_endpoint),
+                Group(*panel_group),
                 title="AgentOS",
                 expand=False,
                 border_style="dark_orange",

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