refactor: Rename default_requires_instance to requires_redis_instance

Simplify the property to return bool instead of Optional[bool].
Base class returns whether redis_instance was provided; subclasses
override to return True or False explicitly.

Author: abrookins

redis_sre_agent/tools/admin/redis_enterprise/provider.py

@@ -101,9 +101,8 @@ def provider_name(self) -> str:
         return "re_admin"  # Shortened to avoid OpenAI 64-char tool name limit
 
     @property
-    def default_requires_instance(self) -> Optional[bool]:
-        """Admin tools always require a Redis Enterprise instance with admin access."""
-
+    def requires_redis_instance(self) -> bool:
+        """Admin tools always require a Redis Enterprise instance."""
         return True
 
     def get_client(self) -> httpx.AsyncClient:

redis_sre_agent/tools/cloud/redis_cloud/provider.py

@@ -144,9 +144,8 @@ def provider_name(self) -> str:
         return "redis_cloud"
 
     @property
-    def default_requires_instance(self) -> Optional[bool]:
-        """Redis Cloud management tools do not require a specific Redis instance."""
-
+    def requires_redis_instance(self) -> bool:
+        """Redis Cloud management tools do not require a Redis instance."""
         return False
 
     def get_client(self) -> GeneratedClient:

redis_sre_agent/tools/diagnostics/redis_command/provider.py

@@ -126,9 +126,8 @@ def provider_name(self) -> str:
         return "redis_command"
 
     @property
-    def default_requires_instance(self) -> Optional[bool]:
-        """Diagnostics tools for redis_command always require a Redis instance."""
-
+    def requires_redis_instance(self) -> bool:
+        """Diagnostics tools always require a Redis instance."""
         return True
 
     def get_client(self) -> Redis:

redis_sre_agent/tools/knowledge/knowledge_base.py

@@ -38,9 +38,8 @@ def provider_name(self) -> str:
         return "knowledge"
 
     @property
-    def default_requires_instance(self) -> Optional[bool]:
-        """Knowledge base tools do not depend on a specific Redis instance."""
-
+    def requires_redis_instance(self) -> bool:
+        """Knowledge base tools do not require a Redis instance."""
         return False
 
     def create_tool_schemas(self) -> List[ToolDefinition]:

redis_sre_agent/tools/protocols.py

@@ -320,23 +320,21 @@ def create_tool_schemas(self) -> List["ToolDefinition"]:
         )
 
     @property
-    def default_requires_instance(self) -> Optional[bool]:
-        """Default ``requires_instance`` flag for this provider's tools.
+    def requires_redis_instance(self) -> bool:
+        """Whether this provider's tools require a Redis instance.
 
-        Returns:
-            * ``True`` if tools always require a Redis instance.
-            * ``False`` if tools never require a Redis instance.
-            * ``None`` (default) to derive from whether ``redis_instance`` was provided.
+        Returns ``True`` if the provider was initialized with a ``redis_instance``.
+        Subclasses can override to always return ``True`` or ``False`` regardless
+        of initialization.
         """
-
-        return None
+        return self.redis_instance is not None
 
     def tools(self) -> List["Tool"]:
         """Return the concrete tools exposed by this provider.
 
         The default implementation builds :class:`Tool` objects from
         :meth:`create_tool_schemas`, using the ``capability`` on each
-        :class:`ToolDefinition` and :attr:`default_requires_instance` to
+        :class:`ToolDefinition` and :attr:`requires_redis_instance` to
         populate :class:`ToolMetadata`.
 
         Each tool's :pyattr:`Tool.invoke` closure is wired directly to the
@@ -351,14 +349,6 @@ def tools(self) -> List["Tool"]:
         # ignore :meth:`create_tool_schemas` entirely.
         schemas: List[ToolDefinition] = self.create_tool_schemas()
 
-        # Determine default requires_instance. ``None`` means derive from the
-        # presence of ``redis_instance``.
-        requires_instance = (
-            bool(self.redis_instance)
-            if self.default_requires_instance is None
-            else bool(self.default_requires_instance)
-        )
-
         tools: List["Tool"] = []
         for schema in schemas:
             capability = schema.capability
@@ -373,7 +363,7 @@ def tools(self) -> List["Tool"]:
                 description=schema.description,
                 capability=capability,
                 provider_name=self.provider_name,
-                requires_instance=requires_instance,
+                requires_instance=self.requires_redis_instance,
             )
 
             # Derive operation name and look up the corresponding method.

redis_sre_agent/tools/utilities/provider.py

@@ -48,9 +48,8 @@ def provider_name(self) -> str:
         return "utilities"
 
     @property
-    def default_requires_instance(self) -> Optional[bool]:
-        """Utility tools do not depend on a specific Redis instance."""
-
+    def requires_redis_instance(self) -> bool:
+        """Utility tools do not require a Redis instance."""
         return False
 
     def create_tool_schemas(self) -> List[ToolDefinition]: