agno 2.0.11__py3-none-any.whl → 2.1.1__py3-none-any.whl

agno/models/google/gemini.py

@@ -26,6 +26,7 @@ try:
     from google.genai.types import (
         Content,
         DynamicRetrievalConfig,
+        FunctionCallingConfigMode,
         GenerateContentConfig,
         GenerateContentResponse,
         GenerateContentResponseUsageMetadata,
@@ -150,6 +151,7 @@ class Gemini(Model):
         system_message: Optional[str] = None,
         response_format: Optional[Union[Dict, Type[BaseModel]]] = None,
         tools: Optional[List[Dict[str, Any]]] = None,
+        tool_choice: Optional[Union[str, Dict[str, Any]]] = None,
     ) -> Dict[str, Any]:
         """
         Returns the request keyword arguments for the GenerativeModel client.
@@ -245,6 +247,18 @@ class Gemini(Model):
         elif tools:
             config["tools"] = [format_function_definitions(tools)]
 
+        if tool_choice is not None:
+            if isinstance(tool_choice, str) and tool_choice.lower() == "auto":
+                config["tool_config"] = {"function_calling_config": {"mode": FunctionCallingConfigMode.AUTO}}
+            elif isinstance(tool_choice, str) and tool_choice.lower() == "none":
+                config["tool_config"] = {"function_calling_config": {"mode": FunctionCallingConfigMode.NONE}}
+            elif isinstance(tool_choice, str) and tool_choice.lower() == "validated":
+                config["tool_config"] = {"function_calling_config": {"mode": FunctionCallingConfigMode.VALIDATED}}
+            elif isinstance(tool_choice, str) and tool_choice.lower() == "any":
+                config["tool_config"] = {"function_calling_config": {"mode": FunctionCallingConfigMode.ANY}}
+            else:
+                config["tool_config"] = {"function_calling_config": {"mode": tool_choice}}
+
         config = {k: v for k, v in config.items() if v is not None}
 
         if config:
@@ -271,7 +285,9 @@ class Gemini(Model):
         Invokes the model with a list of messages and returns the response.
         """
         formatted_messages, system_message = self._format_messages(messages)
-        request_kwargs = self.get_request_params(system_message, response_format=response_format, tools=tools)
+        request_kwargs = self.get_request_params(
+            system_message, response_format=response_format, tools=tools, tool_choice=tool_choice
+        )
         try:
             if run_response and run_response.metrics:
                 run_response.metrics.set_time_to_first_token()
@@ -315,7 +331,9 @@ class Gemini(Model):
         """
         formatted_messages, system_message = self._format_messages(messages)
 
-        request_kwargs = self.get_request_params(system_message, response_format=response_format, tools=tools)
+        request_kwargs = self.get_request_params(
+            system_message, response_format=response_format, tools=tools, tool_choice=tool_choice
+        )
         try:
             if run_response and run_response.metrics:
                 run_response.metrics.set_time_to_first_token()
@@ -356,7 +374,9 @@ class Gemini(Model):
         """
         formatted_messages, system_message = self._format_messages(messages)
 
-        request_kwargs = self.get_request_params(system_message, response_format=response_format, tools=tools)
+        request_kwargs = self.get_request_params(
+            system_message, response_format=response_format, tools=tools, tool_choice=tool_choice
+        )
 
         try:
             if run_response and run_response.metrics:
@@ -400,7 +420,9 @@ class Gemini(Model):
         """
         formatted_messages, system_message = self._format_messages(messages)
 
-        request_kwargs = self.get_request_params(system_message, response_format=response_format, tools=tools)
+        request_kwargs = self.get_request_params(
+            system_message, response_format=response_format, tools=tools, tool_choice=tool_choice
+        )
 
         try:
             if run_response and run_response.metrics:
@@ -1051,9 +1073,9 @@ class Gemini(Model):
 
         metrics.input_tokens = response_usage.prompt_token_count or 0
         metrics.output_tokens = response_usage.candidates_token_count or 0
-        metrics.total_tokens = metrics.input_tokens + metrics.output_tokens
         if response_usage.thoughts_token_count is not None:
             metrics.output_tokens += response_usage.thoughts_token_count or 0
+        metrics.total_tokens = metrics.input_tokens + metrics.output_tokens
 
         metrics.cache_read_tokens = response_usage.cached_content_token_count or 0
 

agno/models/openai/chat.py

@@ -160,6 +160,7 @@ class OpenAIChat(Model):
         response_format: Optional[Union[Dict, Type[BaseModel]]] = None,
         tools: Optional[List[Dict[str, Any]]] = None,
         tool_choice: Optional[Union[str, Dict[str, Any]]] = None,
+        run_response: Optional[RunOutput] = None,
     ) -> Dict[str, Any]:
         """
         Returns keyword arguments for API requests.
@@ -370,7 +371,9 @@ class OpenAIChat(Model):
             provider_response = self.get_client().chat.completions.create(
                 model=self.id,
                 messages=[self._format_message(m) for m in messages],  # type: ignore
-                **self.get_request_params(response_format=response_format, tools=tools, tool_choice=tool_choice),
+                **self.get_request_params(
+                    response_format=response_format, tools=tools, tool_choice=tool_choice, run_response=run_response
+                ),
             )
             assistant_message.metrics.stop_timer()
 
@@ -447,7 +450,9 @@ class OpenAIChat(Model):
             response = await self.get_async_client().chat.completions.create(
                 model=self.id,
                 messages=[self._format_message(m) for m in messages],  # type: ignore
-                **self.get_request_params(response_format=response_format, tools=tools, tool_choice=tool_choice),
+                **self.get_request_params(
+                    response_format=response_format, tools=tools, tool_choice=tool_choice, run_response=run_response
+                ),
             )
             assistant_message.metrics.stop_timer()
 
@@ -524,7 +529,9 @@ class OpenAIChat(Model):
                 messages=[self._format_message(m) for m in messages],  # type: ignore
                 stream=True,
                 stream_options={"include_usage": True},
-                **self.get_request_params(response_format=response_format, tools=tools, tool_choice=tool_choice),
+                **self.get_request_params(
+                    response_format=response_format, tools=tools, tool_choice=tool_choice, run_response=run_response
+                ),
             ):
                 yield self._parse_provider_response_delta(chunk)
 
@@ -598,7 +605,9 @@ class OpenAIChat(Model):
                 messages=[self._format_message(m) for m in messages],  # type: ignore
                 stream=True,
                 stream_options={"include_usage": True},
-                **self.get_request_params(response_format=response_format, tools=tools, tool_choice=tool_choice),
+                **self.get_request_params(
+                    response_format=response_format, tools=tools, tool_choice=tool_choice, run_response=run_response
+                ),
             )
 
             async for chunk in async_stream:

agno/models/openai/responses.py

@@ -45,7 +45,7 @@ class OpenAIResponses(Model):
     parallel_tool_calls: Optional[bool] = None
     reasoning: Optional[Dict[str, Any]] = None
     verbosity: Optional[Literal["low", "medium", "high"]] = None
-    reasoning_effort: Optional[Literal["minimal", "medium", "high"]] = None
+    reasoning_effort: Optional[Literal["minimal", "low", "medium", "high"]] = None
     reasoning_summary: Optional[Literal["auto", "concise", "detailed"]] = None
     store: Optional[bool] = None
     temperature: Optional[float] = None

agno/models/perplexity/perplexity.py

@@ -1,6 +1,6 @@
 from dataclasses import dataclass, field
 from os import getenv
-from typing import Any, Dict, List, Optional, Type, Union
+from typing import Any, Dict, Optional, Type, Union
 
 from pydantic import BaseModel
 
@@ -53,8 +53,7 @@ class Perplexity(OpenAILike):
     def get_request_params(
         self,
         response_format: Optional[Union[Dict, Type[BaseModel]]] = None,
-        tools: Optional[List[Dict[str, Any]]] = None,
-        tool_choice: Optional[Union[str, Dict[str, Any]]] = None,
+        **kwargs: Any,
     ) -> Dict[str, Any]:
         """
         Returns keyword arguments for API requests.

agno/models/requesty/__init__.py

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

agno/models/requesty/requesty.py

@@ -0,0 +1,49 @@
+from dataclasses import dataclass, field
+from os import getenv
+from typing import Any, Dict, List, Optional, Type, Union
+
+from pydantic import BaseModel
+
+from agno.models.openai.like import OpenAILike
+from agno.run.agent import RunOutput
+
+
+@dataclass
+class Requesty(OpenAILike):
+    """
+    A class for using models hosted on Requesty.
+
+    Attributes:
+        id (str): The model id. Defaults to "openai/gpt-4.1".
+        provider (str): The provider name. Defaults to "Requesty".
+        api_key (Optional[str]): The API key.
+        base_url (str): The base URL. Defaults to "https://router.requesty.ai/v1".
+        max_tokens (int): The maximum number of tokens. Defaults to 1024.
+    """
+
+    id: str = "openai/gpt-4.1"
+    name: str = "Requesty"
+    provider: str = "Requesty"
+
+    api_key: Optional[str] = field(default_factory=lambda: getenv("REQUESTY_API_KEY"))
+    base_url: str = "https://router.requesty.ai/v1"
+    max_tokens: int = 1024
+
+    def get_request_params(
+        self,
+        response_format: Optional[Union[Dict, Type[BaseModel]]] = None,
+        tools: Optional[List[Dict[str, Any]]] = None,
+        tool_choice: Optional[Union[str, Dict[str, Any]]] = None,
+        run_response: Optional[RunOutput] = None,
+    ) -> Dict[str, Any]:
+        params = super().get_request_params(response_format=response_format, tools=tools, tool_choice=tool_choice)
+
+        if "extra_body" not in params:
+            params["extra_body"] = {}
+        params["extra_body"]["requesty"] = {}
+        if run_response and run_response.user_id:
+            params["extra_body"]["requesty"]["user_id"] = run_response.user_id
+        if run_response and run_response.session_id:
+            params["extra_body"]["requesty"]["trace_id"] = run_response.session_id
+
+        return params

agno/models/vllm/vllm.py

@@ -57,6 +57,7 @@ class VLLM(OpenAILike):
         response_format: Optional[Union[Dict, Type[BaseModel]]] = None,
         tools: Optional[List[Dict[str, Any]]] = None,
         tool_choice: Optional[Union[str, Dict[str, Any]]] = None,
+        **kwargs: Any,
     ) -> Dict[str, Any]:
         request_kwargs = super().get_request_params(
             response_format=response_format, tools=tools, tool_choice=tool_choice

agno/models/xai/xai.py

@@ -44,6 +44,7 @@ class xAI(OpenAILike):
         response_format: Optional[Union[Dict, Type[BaseModel]]] = None,
         tools: Optional[List[Dict[str, Any]]] = None,
         tool_choice: Optional[Union[str, Dict[str, Any]]] = None,
+        **kwargs: Any,
     ) -> Dict[str, Any]:
         """
         Returns keyword arguments for API requests, including search parameters.

agno/os/app.py

@@ -1,7 +1,7 @@
 from contextlib import asynccontextmanager
 from functools import partial
 from os import getenv
-from typing import Any, Dict, List, Optional, Set, Union
+from typing import Any, Dict, List, Literal, Optional, Union
 from uuid import uuid4
 
 from fastapi import APIRouter, FastAPI, HTTPException
@@ -40,6 +40,8 @@ from agno.os.settings import AgnoAPISettings
 from agno.os.utils import (
     collect_mcp_tools_from_team,
     collect_mcp_tools_from_workflow,
+    find_conflicting_routes,
+    load_yaml_config,
     update_cors_middleware,
 )
 from agno.team.team import Team
@@ -49,7 +51,7 @@ from agno.workflow.workflow import Workflow
 
 
 @asynccontextmanager
-async def mcp_lifespan(app, mcp_tools):
+async def mcp_lifespan(_, mcp_tools):
     """Manage MCP connection lifecycle inside a FastAPI app"""
     # Startup logic: connect to all contextual MCP servers
     for tool in mcp_tools:
@@ -65,7 +67,8 @@ async def mcp_lifespan(app, mcp_tools):
 class AgentOS:
     def __init__(
         self,
-        os_id: Optional[str] = None,
+        id: Optional[str] = None,
+        os_id: Optional[str] = None,  # Deprecated
         name: Optional[str] = None,
         description: Optional[str] = None,
         version: Optional[str] = None,
@@ -75,16 +78,19 @@ class AgentOS:
         interfaces: Optional[List[BaseInterface]] = None,
         config: Optional[Union[str, AgentOSConfig]] = None,
         settings: Optional[AgnoAPISettings] = None,
-        fastapi_app: Optional[FastAPI] = None,
         lifespan: Optional[Any] = None,
-        enable_mcp: bool = False,
-        replace_routes: bool = True,
+        enable_mcp: bool = False,  # Deprecated
+        enable_mcp_server: bool = False,
+        fastapi_app: Optional[FastAPI] = None,  # Deprecated
+        base_app: Optional[FastAPI] = None,
+        replace_routes: Optional[bool] = None,  # Deprecated
+        on_route_conflict: Literal["preserve_agentos", "preserve_base_app", "error"] = "preserve_agentos",
         telemetry: bool = True,
     ):
         """Initialize AgentOS.
 
         Args:
-            os_id: Unique identifier for this AgentOS instance
+            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
@@ -94,18 +100,16 @@ class AgentOS:
             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.
+            enable_mcp_server: Whether to enable MCP (Model Context Protocol)
+            base_app: Optional base FastAPI app to use for the AgentOS. All routes and middleware will be added to this app.
+            on_route_conflict: What to do when a route conflict is detected in case a custom base_app is provided.
             telemetry: Whether to enable telemetry
         """
         if not agents and not workflows and not teams:
             raise ValueError("Either agents, teams or workflows must be provided.")
 
-        self.config = self._load_yaml_config(config) if isinstance(config, str) else config
+        self.config = load_yaml_config(config) if isinstance(config, str) else config
 
         self.agents: Optional[List[Agent]] = agents
         self.workflows: Optional[List[Workflow]] = workflows
@@ -115,27 +119,42 @@ class AgentOS:
         self.settings: AgnoAPISettings = settings or AgnoAPISettings()
 
         self._app_set = False
-        self.fastapi_app: Optional[FastAPI] = None
-        if fastapi_app:
-            self.fastapi_app = fastapi_app
+
+        if base_app:
+            self.base_app: Optional[FastAPI] = base_app
+            self._app_set = True
+            self.on_route_conflict = on_route_conflict
+        elif fastapi_app:
+            self.base_app = fastapi_app
             self._app_set = True
+            if replace_routes is not None:
+                self.on_route_conflict = "preserve_agentos" if replace_routes else "preserve_base_app"
+            else:
+                self.on_route_conflict = on_route_conflict
+        else:
+            self.base_app = None
+            self._app_set = False
+            self.on_route_conflict = on_route_conflict
 
         self.interfaces = interfaces or []
 
-        self.os_id = os_id
         self.name = name
+
+        self.id = id or os_id
+        if not self.id:
+            self.id = generate_id(self.name) if self.name else str(uuid4())
+
         self.version = version
         self.description = description
 
-        self.replace_routes = replace_routes
-
         self.telemetry = telemetry
 
-        self.enable_mcp = enable_mcp
+        self.enable_mcp_server = enable_mcp or enable_mcp_server
         self.lifespan = lifespan
 
         # List of all MCP tools used inside the AgentOS
         self.mcp_tools: List[Any] = []
+        self._mcp_app: Optional[Any] = None
 
         if self.agents:
             for agent in self.agents:
@@ -177,13 +196,10 @@ class AgentOS:
                 if not workflow.id:
                     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
 
-            log_os_telemetry(launch=OSLaunch(os_id=self.os_id, data=self._get_telemetry_data()))
+            log_os_telemetry(launch=OSLaunch(os_id=self.id, data=self._get_telemetry_data()))
 
     def _make_app(self, lifespan: Optional[Any] = None) -> FastAPI:
         # Adjust the FastAPI app lifespan to handle MCP connections if relevant
@@ -215,39 +231,41 @@ class AgentOS:
         )
 
     def get_app(self) -> FastAPI:
-        if not self.fastapi_app:
-            if self.enable_mcp:
+        if self.base_app:
+            fastapi_app = self.base_app
+        else:
+            if self.enable_mcp_server:
                 from contextlib import asynccontextmanager
 
                 from agno.os.mcp import get_mcp_server
 
-                self.mcp_app = get_mcp_server(self)
+                self._mcp_app = get_mcp_server(self)
 
-                final_lifespan = self.mcp_app.lifespan
+                final_lifespan = self._mcp_app.lifespan  # type: ignore
                 if self.lifespan is not None:
                     # Combine both lifespans
                     @asynccontextmanager
                     async def combined_lifespan(app: FastAPI):
                         # Run both lifespans
                         async with self.lifespan(app):  # type: ignore
-                            async with self.mcp_app.lifespan(app):  # type: ignore
+                            async with self._mcp_app.lifespan(app):  # type: ignore
                                 yield
 
                     final_lifespan = combined_lifespan  # type: ignore
 
-                self.fastapi_app = self._make_app(lifespan=final_lifespan)
+                fastapi_app = self._make_app(lifespan=final_lifespan)
             else:
-                self.fastapi_app = self._make_app(lifespan=self.lifespan)
+                fastapi_app = self._make_app(lifespan=self.lifespan)
 
-        # 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))
+        # Add routes
+        self._add_router(fastapi_app, get_base_router(self, settings=self.settings))
+        self._add_router(fastapi_app, get_websocket_router(self, settings=self.settings))
+        self._add_router(fastapi_app, get_health_router())
+        self._add_router(fastapi_app, get_home_router(self))
 
         for interface in self.interfaces:
             interface_router = interface.get_router()
-            self._add_router(interface_router)
+            self._add_router(fastapi_app, interface_router)
 
         self._auto_discover_databases()
         self._auto_discover_knowledge_instances()
@@ -261,17 +279,19 @@ class AgentOS:
         ]
 
         for router in routers:
-            self._add_router(router)
+            self._add_router(fastapi_app, router)
 
         # Mount MCP if needed
-        if self.enable_mcp and self.mcp_app:
-            self.fastapi_app.mount("/", self.mcp_app)
+        if self.enable_mcp_server and self._mcp_app:
+            fastapi_app.mount("/", self._mcp_app)
+        else:
+            # Add the home router
+            self._add_router(fastapi_app, get_home_router(self))
 
-        # Add middleware (only if app is not set)
         if not self._app_set:
 
-            @self.fastapi_app.exception_handler(HTTPException)
-            async def http_exception_handler(request: Request, exc: HTTPException) -> JSONResponse:
+            @fastapi_app.exception_handler(HTTPException)
+            async def http_exception_handler(_, exc: HTTPException) -> JSONResponse:
                 return JSONResponse(
                     status_code=exc.status_code,
                     content={"detail": str(exc.detail)},
@@ -286,12 +306,12 @@ class AgentOS:
                         content={"detail": str(e)},
                     )
 
-            self.fastapi_app.middleware("http")(general_exception_handler)
+            fastapi_app.middleware("http")(general_exception_handler)
 
         # Update CORS middleware
-        update_cors_middleware(self.fastapi_app, self.settings.cors_origin_list)  # type: ignore
+        update_cors_middleware(fastapi_app, self.settings.cors_origin_list)  # type: ignore
 
-        return self.fastapi_app
+        return fastapi_app
 
     def get_routes(self) -> List[Any]:
         """Retrieve all routes from the FastAPI app.
@@ -303,55 +323,37 @@ 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:
+    def _add_router(self, fastapi_app: FastAPI, 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()
+        conflicts = find_conflicting_routes(fastapi_app, router)
+        conflicting_routes = [conflict["route"] for conflict in conflicts]
 
-        # Check for conflicts
-        conflicts = []
-        conflicting_routes = []
+        if conflicts and self._app_set:
+            if self.on_route_conflict == "preserve_base_app":
+                # 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"
+                    )
 
-        for route in router.routes:
-            if isinstance(route, APIRoute):
-                full_path = route.path
-                route_methods = list(route.methods) if route.methods else []
+                # 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)
 
-                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)
+                # Use the filtered router if it has any routes left
+                if filtered_router.routes:
+                    fastapi_app.include_router(filtered_router)
 
-        if conflicts and self._app_set:
-            if self.replace_routes:
+            elif self.on_route_conflict == "preserve_agentos":
                 # Log warnings but still add all routes (AgentOS routes will override)
                 for conflict in conflicts:
                     methods_str = ", ".join(conflict["methods"])  # type: ignore
@@ -361,35 +363,21 @@ class AgentOS:
                     )
 
                 # Remove conflicting routes
-                for route in self.fastapi_app.routes:
+                for route in fastapi_app.routes:
                     for conflict in conflicts:
                         if isinstance(route, APIRoute):
                             if route.path == conflict["path"] and list(route.methods) == list(conflict["methods"]):  # type: ignore
-                                self.fastapi_app.routes.pop(self.fastapi_app.routes.index(route))
+                                fastapi_app.routes.pop(fastapi_app.routes.index(route))
 
-                self.fastapi_app.include_router(router)
+                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"
-                    )
+            elif self.on_route_conflict == "error":
+                conflicting_paths = [conflict["path"] for conflict in conflicts]
+                raise ValueError(f"Route conflict detected: {conflicting_paths}")
 
-                # 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)
+            fastapi_app.include_router(router)
 
     def _get_telemetry_data(self) -> Dict[str, Any]:
         """Get the telemetry data for the OS"""
@@ -400,21 +388,6 @@ class AgentOS:
             "interfaces": [interface.type for interface in self.interfaces] if self.interfaces else None,
         }
 
-    def _load_yaml_config(self, config_file_path: str) -> AgentOSConfig:
-        """Load a YAML config file and return the configuration as an AgentOSConfig instance."""
-        from pathlib import Path
-
-        import yaml
-
-        # Validate that the path points to a YAML file
-        path = Path(config_file_path)
-        if path.suffix.lower() not in [".yaml", ".yml"]:
-            raise ValueError(f"Config file must have a .yaml or .yml extension, got: {config_file_path}")
-
-        # Load the YAML file
-        with open(config_file_path, "r") as f:
-            return AgentOSConfig.model_validate(yaml.safe_load(f))
-
     def _auto_discover_databases(self) -> None:
         """Auto-discover the databases used by all contextual agents, teams and workflows."""
         from agno.db.base import BaseDb
@@ -641,11 +614,10 @@ class AgentOS:
         from rich.align import Align
         from rich.console import Console, Group
 
-        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}")
-        )
+        panel_group = [
+            Align.center(f"[bold cyan]{public_endpoint}[/bold cyan]"),
+            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]"))
 

agno/os/interfaces/__init__.py

@@ -0,0 +1 @@
+