agno 2.3.14__py3-none-any.whl → 2.3.16__py3-none-any.whl

agno/os/auth.py

@@ -1,3 +1,4 @@
+from os import getenv
 from typing import List, Set
 
 from fastapi import Depends, HTTPException, Request
@@ -10,18 +11,43 @@ from agno.os.settings import AgnoAPISettings
 security = HTTPBearer(auto_error=False)
 
 
+def _is_jwt_configured() -> bool:
+    """Check if JWT authentication is configured via environment variables.
+
+    This covers cases where JWT middleware is set up manually (not via authorization=True).
+    """
+    return bool(getenv("JWT_VERIFICATION_KEY") or getenv("JWT_JWKS_FILE"))
+
+
 def get_authentication_dependency(settings: AgnoAPISettings):
     """
     Create an authentication dependency function for FastAPI routes.
 
+    This handles security key authentication (OS_SECURITY_KEY).
+    When JWT authorization is enabled (via authorization=True, JWT environment variables,
+    or manually added JWT middleware), this dependency is skipped as JWT middleware
+    handles authentication.
+
     Args:
-        settings: The API settings containing the security key
+        settings: The API settings containing the security key and authorization flag
 
     Returns:
         A dependency function that can be used with FastAPI's Depends()
     """
 
-    async def auth_dependency(credentials: HTTPAuthorizationCredentials = Depends(security)) -> bool:
+    async def auth_dependency(request: Request, credentials: HTTPAuthorizationCredentials = Depends(security)) -> bool:
+        # If JWT authorization is enabled via settings (authorization=True on AgentOS)
+        if settings and settings.authorization_enabled:
+            return True
+
+        # Check if JWT middleware has already handled authentication
+        if getattr(request.state, "authenticated", False):
+            return True
+
+        # Also skip if JWT is configured via environment variables
+        if _is_jwt_configured():
+            return True
+
         # If no security key is set, skip authentication entirely
         if not settings or not settings.os_security_key:
             return True
@@ -45,13 +71,24 @@ def validate_websocket_token(token: str, settings: AgnoAPISettings) -> bool:
     """
     Validate a bearer token for WebSocket authentication (legacy os_security_key method).
 
+    When JWT authorization is enabled (via authorization=True or JWT environment variables),
+    this validation is skipped as JWT middleware handles authentication.
+
     Args:
         token: The bearer token to validate
-        settings: The API settings containing the security key
+        settings: The API settings containing the security key and authorization flag
 
     Returns:
         True if the token is valid or authentication is disabled, False otherwise
     """
+    # If JWT authorization is enabled, skip security key validation
+    if settings and settings.authorization_enabled:
+        return True
+
+    # Also skip if JWT is configured via environment variables (manual JWT middleware setup)
+    if _is_jwt_configured():
+        return True
+
     # If no security key is set, skip authentication entirely
     if not settings or not settings.os_security_key:
         return True

agno/os/router.py

@@ -1,16 +1,11 @@
-from typing import TYPE_CHECKING, List, Optional, Union, cast
+from typing import TYPE_CHECKING, List, Union, cast
 
 from fastapi import (
     APIRouter,
     Depends,
-    HTTPException,
 )
-from fastapi.responses import JSONResponse
-from packaging import version
 
 from agno.agent.agent import Agent
-from agno.db.base import AsyncBaseDb
-from agno.db.migrations.manager import MigrationManager
 from agno.os.auth import get_authentication_dependency
 from agno.os.schema import (
     AgentSummaryResponse,
@@ -26,9 +21,6 @@ from agno.os.schema import (
     WorkflowSummaryResponse,
 )
 from agno.os.settings import AgnoAPISettings
-from agno.os.utils import (
-    get_db,
-)
 from agno.team.team import Team
 
 if TYPE_CHECKING:
@@ -207,52 +199,4 @@ def get_base_router(
 
         return list(unique_models.values())
 
-    # -- Database Migration routes ---
-    @router.post(
-        "/databases/{db_id}/migrate",
-        tags=["Database"],
-        operation_id="migrate_database",
-        summary="Migrate Database",
-        description=(
-            "Migrate the given database schema to the given target version. "
-            "If a target version is not provided, the database will be migrated to the latest version. "
-        ),
-        responses={
-            200: {
-                "description": "Database migrated successfully",
-                "content": {
-                    "application/json": {
-                        "example": {"message": "Database migrated successfully to version 3.0.0"},
-                    }
-                },
-            },
-            404: {"description": "Database not found", "model": NotFoundResponse},
-            500: {"description": "Failed to migrate database", "model": InternalServerErrorResponse},
-        },
-    )
-    async def migrate_database(db_id: str, target_version: Optional[str] = None):
-        db = await get_db(os.dbs, db_id)
-        if not db:
-            raise HTTPException(status_code=404, detail="Database not found")
-
-        if target_version:
-            # Use the session table as proxy for the database schema version
-            if isinstance(db, AsyncBaseDb):
-                current_version = await db.get_latest_schema_version(db.session_table_name)
-            else:
-                current_version = db.get_latest_schema_version(db.session_table_name)
-
-            if version.parse(target_version) > version.parse(current_version):  # type: ignore
-                MigrationManager(db).up(target_version)  # type: ignore
-            else:
-                MigrationManager(db).down(target_version)  # type: ignore
-
-        # If the target version is not provided, migrate to the latest version
-        else:
-            MigrationManager(db).up()  # type: ignore
-
-        return JSONResponse(
-            content={"message": f"Database migrated successfully to version {target_version}"}, status_code=200
-        )
-
     return router

agno/os/routers/database.py

@@ -0,0 +1,150 @@
+from typing import TYPE_CHECKING, Optional
+
+from fastapi import (
+    APIRouter,
+    Depends,
+    HTTPException,
+)
+from fastapi.responses import JSONResponse
+from packaging import version
+
+from agno.db.base import AsyncBaseDb
+from agno.db.migrations.manager import MigrationManager
+from agno.os.auth import get_authentication_dependency
+from agno.os.schema import (
+    BadRequestResponse,
+    InternalServerErrorResponse,
+    NotFoundResponse,
+    UnauthenticatedResponse,
+    ValidationErrorResponse,
+)
+from agno.os.settings import AgnoAPISettings
+from agno.os.utils import (
+    get_db,
+)
+
+if TYPE_CHECKING:
+    from agno.os.app import AgentOS
+
+
+def get_database_router(
+    os: "AgentOS",
+    settings: AgnoAPISettings = AgnoAPISettings(),
+) -> APIRouter:
+    """Create the database router with comprehensive OpenAPI documentation."""
+    router = APIRouter(
+        dependencies=[Depends(get_authentication_dependency(settings))],
+        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},
+        },
+    )
+
+    async def _migrate_single_db(db, target_version: Optional[str] = None) -> None:
+        """Migrate a single database."""
+        if target_version:
+            # Use the session table as proxy for the database schema version
+            if isinstance(db, AsyncBaseDb):
+                current_version = await db.get_latest_schema_version(db.session_table_name)
+            else:
+                current_version = db.get_latest_schema_version(db.session_table_name)
+
+            if version.parse(target_version) > version.parse(current_version):  # type: ignore
+                await MigrationManager(db).up(target_version)  # type: ignore
+            else:
+                await MigrationManager(db).down(target_version)  # type: ignore
+        else:
+            # If the target version is not provided, migrate to the latest version
+            await MigrationManager(db).up()  # type: ignore
+
+    @router.post(
+        "/databases/all/migrate",
+        tags=["Database"],
+        operation_id="migrate_all_databases",
+        summary="Migrate All Databases",
+        description=(
+            "Migrate all database schemas to the given target version. "
+            "If a target version is not provided, all databases will be migrated to the latest version."
+        ),
+        responses={
+            200: {
+                "description": "All databases migrated successfully",
+                "content": {
+                    "application/json": {
+                        "example": {"message": "All databases migrated successfully to version 3.0.0"},
+                    }
+                },
+            },
+            500: {"description": "Failed to migrate databases", "model": InternalServerErrorResponse},
+        },
+    )
+    async def migrate_all_databases(target_version: Optional[str] = None):
+        """Migrate all databases."""
+        all_dbs = {db.id: db for db_id, dbs in os.dbs.items() for db in dbs}
+        failed_dbs: dict[str, str] = {}
+
+        for db_id, db in all_dbs.items():
+            try:
+                await _migrate_single_db(db, target_version)
+            except Exception as e:
+                failed_dbs[db_id] = str(e)
+
+        version_msg = f"version {target_version}" if target_version else "latest version"
+        migrated_count = len(all_dbs) - len(failed_dbs)
+
+        if failed_dbs:
+            return JSONResponse(
+                content={
+                    "message": f"Migrated {migrated_count}/{len(all_dbs)} databases to {version_msg}",
+                    "failed": failed_dbs,
+                },
+                status_code=207,  # Multi-Status
+            )
+
+        return JSONResponse(
+            content={"message": f"All databases migrated successfully to {version_msg}"}, status_code=200
+        )
+
+    @router.post(
+        "/databases/{db_id}/migrate",
+        tags=["Database"],
+        operation_id="migrate_database",
+        summary="Migrate Database",
+        description=(
+            "Migrate the given database schema to the given target version. "
+            "If a target version is not provided, the database will be migrated to the latest version."
+        ),
+        responses={
+            200: {
+                "description": "Database migrated successfully",
+                "content": {
+                    "application/json": {
+                        "example": {"message": "Database migrated successfully to version 3.0.0"},
+                    }
+                },
+            },
+            404: {"description": "Database not found", "model": NotFoundResponse},
+            500: {"description": "Failed to migrate database", "model": InternalServerErrorResponse},
+        },
+    )
+    async def migrate_database(db_id: str, target_version: Optional[str] = None):
+        db = await get_db(os.dbs, db_id)
+        if not db:
+            raise HTTPException(status_code=404, detail="Database not found")
+
+        try:
+            await _migrate_single_db(db, target_version)
+
+            version_msg = f"version {target_version}" if target_version else "latest version"
+            return JSONResponse(
+                content={"message": f"Database migrated successfully to {version_msg}"}, status_code=200
+            )
+        except HTTPException:
+            raise
+        except Exception as e:
+            raise HTTPException(status_code=500, detail=f"Failed to migrate database: {str(e)}")
+
+    return router

agno/os/settings.py

@@ -20,6 +20,9 @@ class AgnoAPISettings(BaseSettings):
     # Authentication settings
     os_security_key: Optional[str] = Field(default=None, description="Bearer token for API authentication")
 
+    # Authorization flag - when True, JWT middleware handles auth and security key validation is skipped
+    authorization_enabled: bool = Field(default=False, description="Whether JWT authorization is enabled")
+
     # Cors origin list to allow requests from.
     # This list is set using the set_cors_origin_list validator
     cors_origin_list: Optional[List[str]] = Field(default=None, validate_default=True)

agno/run/agent.py

@@ -153,6 +153,7 @@ class RunEvent(str, Enum):
 
     tool_call_started = "ToolCallStarted"
     tool_call_completed = "ToolCallCompleted"
+    tool_call_error = "ToolCallError"
 
     reasoning_started = "ReasoningStarted"
     reasoning_step = "ReasoningStep"
@@ -405,6 +406,13 @@ class ToolCallCompletedEvent(BaseAgentRunEvent):
     audio: Optional[List[Audio]] = None  # Audio produced by the tool call
 
 
+@dataclass
+class ToolCallErrorEvent(BaseAgentRunEvent):
+    event: str = RunEvent.tool_call_error.value
+    tool: Optional[ToolExecution] = None
+    error: Optional[str] = None
+
+
 @dataclass
 class ParserModelResponseStartedEvent(BaseAgentRunEvent):
     event: str = RunEvent.parser_model_response_started.value
@@ -459,6 +467,7 @@ RunOutputEvent = Union[
     SessionSummaryCompletedEvent,
     ToolCallStartedEvent,
     ToolCallCompletedEvent,
+    ToolCallErrorEvent,
     ParserModelResponseStartedEvent,
     ParserModelResponseCompletedEvent,
     OutputModelResponseStartedEvent,
@@ -492,6 +501,7 @@ RUN_EVENT_TYPE_REGISTRY = {
     RunEvent.session_summary_completed.value: SessionSummaryCompletedEvent,
     RunEvent.tool_call_started.value: ToolCallStartedEvent,
     RunEvent.tool_call_completed.value: ToolCallCompletedEvent,
+    RunEvent.tool_call_error.value: ToolCallErrorEvent,
     RunEvent.parser_model_response_started.value: ParserModelResponseStartedEvent,
     RunEvent.parser_model_response_completed.value: ParserModelResponseCompletedEvent,
     RunEvent.output_model_response_started.value: OutputModelResponseStartedEvent,

agno/run/base.py

@@ -51,6 +51,7 @@ class BaseRunOutputEvent:
                 "session_summary",
                 "metrics",
                 "run_input",
+                "requirements",
             ]
         }
 
@@ -138,6 +139,9 @@ class BaseRunOutputEvent:
         if hasattr(self, "run_input") and self.run_input is not None:
             _dict["run_input"] = self.run_input.to_dict()
 
+        if hasattr(self, "requirements") and self.requirements is not None:
+            _dict["requirements"] = [req.to_dict() if hasattr(req, "to_dict") else req for req in self.requirements]
+
         return _dict
 
     def to_json(self, separators=(", ", ": "), indent: Optional[int] = 2) -> str:
@@ -219,6 +223,21 @@ class BaseRunOutputEvent:
 
                 data["run_input"] = RunInput.from_dict(run_input)
 
+                # Handle requirements
+
+        # Handle requirements
+        requirements_data = data.pop("requirements", None)
+        if requirements_data is not None:
+            from agno.run.requirement import RunRequirement
+
+            requirements_list: List[RunRequirement] = []
+            for item in requirements_data:
+                if isinstance(item, RunRequirement):
+                    requirements_list.append(item)
+                elif isinstance(item, dict):
+                    requirements_list.append(RunRequirement.from_dict(item))
+            data["requirements"] = requirements_list if requirements_list else None
+
         # Filter data to only include fields that are actually defined in the target class
         from dataclasses import fields
 

agno/run/team.py

@@ -146,6 +146,7 @@ class TeamRunEvent(str, Enum):
 
     tool_call_started = "TeamToolCallStarted"
     tool_call_completed = "TeamToolCallCompleted"
+    tool_call_error = "TeamToolCallError"
 
     reasoning_started = "TeamReasoningStarted"
     reasoning_step = "TeamReasoningStep"
@@ -378,6 +379,13 @@ class ToolCallCompletedEvent(BaseTeamRunEvent):
     audio: Optional[List[Audio]] = None  # Audio produced by the tool call
 
 
+@dataclass
+class ToolCallErrorEvent(BaseTeamRunEvent):
+    event: str = TeamRunEvent.tool_call_error.value
+    tool: Optional[ToolExecution] = None
+    error: Optional[str] = None
+
+
 @dataclass
 class ParserModelResponseStartedEvent(BaseTeamRunEvent):
     event: str = TeamRunEvent.parser_model_response_started.value
@@ -428,6 +436,7 @@ TeamRunOutputEvent = Union[
     SessionSummaryCompletedEvent,
     ToolCallStartedEvent,
     ToolCallCompletedEvent,
+    ToolCallErrorEvent,
     ParserModelResponseStartedEvent,
     ParserModelResponseCompletedEvent,
     OutputModelResponseStartedEvent,
@@ -458,6 +467,7 @@ TEAM_RUN_EVENT_TYPE_REGISTRY = {
     TeamRunEvent.session_summary_completed.value: SessionSummaryCompletedEvent,
     TeamRunEvent.tool_call_started.value: ToolCallStartedEvent,
     TeamRunEvent.tool_call_completed.value: ToolCallCompletedEvent,
+    TeamRunEvent.tool_call_error.value: ToolCallErrorEvent,
     TeamRunEvent.parser_model_response_started.value: ParserModelResponseStartedEvent,
     TeamRunEvent.parser_model_response_completed.value: ParserModelResponseCompletedEvent,
     TeamRunEvent.output_model_response_started.value: OutputModelResponseStartedEvent,

agno/team/team.py

@@ -129,6 +129,7 @@ from agno.utils.events import (
     create_team_session_summary_completed_event,
     create_team_session_summary_started_event,
     create_team_tool_call_completed_event,
+    create_team_tool_call_error_event,
     create_team_tool_call_started_event,
     handle_event,
 )
@@ -3831,6 +3832,15 @@ class Team:
                                 events_to_skip=self.events_to_skip,
                                 store_events=self.store_events,
                             )
+                            if tool_call.tool_call_error:
+                                yield handle_event(  # type: ignore
+                                    create_team_tool_call_error_event(
+                                        from_run_response=run_response, tool=tool_call, error=str(tool_call.result)
+                                    ),
+                                    run_response,
+                                    events_to_skip=self.events_to_skip,
+                                    store_events=self.store_events,
+                                )
 
                 if stream_events:
                     if reasoning_step is not None:

agno/tools/toolkit.py

@@ -1,5 +1,5 @@
 from collections import OrderedDict
-from typing import Any, Callable, Dict, List, Optional
+from typing import Any, Callable, Dict, List, Optional, Sequence, Union
 
 from agno.tools.function import Function
 from agno.utils.log import log_debug, log_warning, logger
@@ -13,7 +13,7 @@ class Toolkit:
     def __init__(
         self,
         name: str = "toolkit",
-        tools: List[Callable] = [],
+        tools: Sequence[Union[Callable[..., Any], Function]] = [],
         instructions: Optional[str] = None,
         add_instructions: bool = False,
         include_tools: Optional[list[str]] = None,
@@ -31,7 +31,7 @@ class Toolkit:
 
         Args:
             name: A descriptive name for the toolkit
-            tools: List of tools to include in the toolkit
+            tools: List of tools to include in the toolkit (can be callables or Function objects from @tool decorator)
             instructions: Instructions for the toolkit
             add_instructions: Whether to add instructions to the toolkit
             include_tools: List of tool names to include in the toolkit
@@ -46,7 +46,7 @@ class Toolkit:
             show_result_tools (Optional[List[str]]): List of function names whose results should be shown.
         """
         self.name: str = name
-        self.tools: List[Callable] = tools
+        self.tools: Sequence[Union[Callable[..., Any], Function]] = tools
         self.functions: Dict[str, Function] = OrderedDict()
         self.instructions: Optional[str] = instructions
         self.add_instructions: bool = add_instructions
@@ -58,7 +58,9 @@ class Toolkit:
         self.show_result_tools: list[str] = show_result_tools or []
 
         self._check_tools_filters(
-            available_tools=[tool.__name__ for tool in tools], include_tools=include_tools, exclude_tools=exclude_tools
+            available_tools=[self._get_tool_name(tool) for tool in tools],
+            include_tools=include_tools,
+            exclude_tools=exclude_tools,
         )
 
         self.include_tools = include_tools
@@ -72,6 +74,12 @@ class Toolkit:
         if auto_register and self.tools:
             self._register_tools()
 
+    def _get_tool_name(self, tool: Union[Callable[..., Any], Function]) -> str:
+        """Get the name of a tool, whether it's a Function or callable."""
+        if isinstance(tool, Function):
+            return tool.name
+        return tool.__name__
+
     def _check_tools_filters(
         self,
         available_tools: List[str],
@@ -104,22 +112,45 @@ class Toolkit:
                     f"External execution required tool(s) not present in the toolkit: {', '.join(missing_external_execution_required)}"
                 )
 
+        if self.stop_after_tool_call_tools:
+            missing_stop_after_tool_call = set(self.stop_after_tool_call_tools) - set(available_tools)
+            if missing_stop_after_tool_call:
+                log_warning(
+                    f"Stop after tool call tool(s) not present in the toolkit: {', '.join(missing_stop_after_tool_call)}"
+                )
+
+        if self.show_result_tools:
+            missing_show_result = set(self.show_result_tools) - set(available_tools)
+            if missing_show_result:
+                log_warning(f"Show result tool(s) not present in the toolkit: {', '.join(missing_show_result)}")
+
     def _register_tools(self) -> None:
         """Register all tools."""
         for tool in self.tools:
             self.register(tool)
 
-    def register(self, function: Callable[..., Any], name: Optional[str] = None):
+    def register(self, function: Union[Callable[..., Any], Function], name: Optional[str] = None) -> None:
         """Register a function with the toolkit.
 
+        This method supports both regular callables and Function objects (from @tool decorator).
+        When a Function object is passed (e.g., from a @tool decorated method), it will:
+        1. Extract the configuration from the Function object
+        2. Look for a bound method with the same name on `self`
+        3. Create a new Function with the bound method as entrypoint, preserving decorator settings
+
         Args:
-            function: The callable to register
+            function: The callable or Function object to register
             name: Optional custom name for the function
 
         Returns:
             The registered function
         """
         try:
+            # Handle Function objects (from @tool decorator)
+            if isinstance(function, Function):
+                return self._register_decorated_tool(function, name)
+
+            # Handle regular callables
             tool_name = name or function.__name__
             if self.include_tools is not None and tool_name not in self.include_tools:
                 return
@@ -140,9 +171,89 @@ class Toolkit:
             self.functions[f.name] = f
             log_debug(f"Function: {f.name} registered with {self.name}")
         except Exception as e:
-            logger.warning(f"Failed to create Function for: {function.__name__}")
+            func_name = self._get_tool_name(function)
+            logger.warning(f"Failed to create Function for: {func_name}")
             raise e
 
+    def _register_decorated_tool(self, function: Function, name: Optional[str] = None) -> None:
+        """Register a Function object from @tool decorator, binding it to self.
+
+        When @tool decorator is used on a class method, it creates a Function with an unbound
+        method as entrypoint. This method creates a bound version of the entrypoint that
+        includes `self`, preserving all decorator settings.
+
+        Args:
+            function: The Function object from @tool decorator
+            name: Optional custom name override
+        """
+        import inspect
+
+        tool_name = name or function.name
+        if self.include_tools is not None and len(self.include_tools) > 0 and tool_name not in self.include_tools:
+            return
+        if self.exclude_tools is not None and len(self.exclude_tools) > 0 and tool_name in self.exclude_tools:
+            return
+
+        # Get the original entrypoint from the Function
+        if function.entrypoint is None:
+            log_warning(f"Function '{tool_name}' has no entrypoint, skipping registration")
+            return
+
+        original_func = function.entrypoint
+
+        # Check if the function expects 'self' as first argument (i.e., it's an unbound method)
+        sig = inspect.signature(original_func)
+        params = list(sig.parameters.keys())
+
+        if params and params[0] == "self":
+            # Create a bound method by wrapping the function to include self
+            def make_bound_method(func, instance):
+                def bound(*args, **kwargs):
+                    return func(instance, *args, **kwargs)
+
+                # Preserve function metadata for debugging
+                bound.__name__ = getattr(func, "__name__", tool_name)
+                bound.__doc__ = getattr(func, "__doc__", None)
+                return bound
+
+            bound_method = make_bound_method(original_func, self)
+        else:
+            # Function doesn't expect self (e.g., static method or already bound)
+            bound_method = original_func
+
+        # decorator settings take precedence, then toolkit settings
+        stop_after = function.stop_after_tool_call or tool_name in self.stop_after_tool_call_tools
+        show_result = function.show_result or tool_name in self.show_result_tools or stop_after
+        requires_confirmation = function.requires_confirmation or tool_name in self.requires_confirmation_tools
+        external_execution = function.external_execution or tool_name in self.external_execution_required_tools
+
+        # Create new Function with bound method, preserving decorator settings
+        f = Function(
+            name=tool_name,
+            description=function.description,
+            parameters=function.parameters,
+            strict=function.strict,
+            instructions=function.instructions,
+            add_instructions=function.add_instructions,
+            entrypoint=bound_method,
+            skip_entrypoint_processing=True,  # Parameters already processed by decorator
+            show_result=show_result,
+            stop_after_tool_call=stop_after,
+            pre_hook=function.pre_hook,
+            post_hook=function.post_hook,
+            tool_hooks=function.tool_hooks,
+            requires_confirmation=requires_confirmation,
+            requires_user_input=function.requires_user_input,
+            user_input_fields=function.user_input_fields,
+            user_input_schema=function.user_input_schema,
+            external_execution=external_execution,
+            cache_results=function.cache_results if function.cache_results else self.cache_results,
+            cache_dir=function.cache_dir if function.cache_dir else self.cache_dir,
+            cache_ttl=function.cache_ttl if function.cache_ttl != 3600 else self.cache_ttl,
+        )
+        self.functions[f.name] = f
+        log_debug(f"Function: {f.name} registered with {self.name} (from @tool decorator)")
+
     @property
     def requires_connect(self) -> bool:
         """Whether the toolkit requires connection management."""