Remove _disabled set, let registry be single source of truth for agent enabled state.

Disabled agents are simply not registered — no separate _disabled tracking,
no redundant config re-reads in execute_agent or list_agents API.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: jmchilton

lib/galaxy/agents/registry.py

@@ -22,7 +22,6 @@ def __init__(self):
         """Initialize empty registry."""
         self._agents: dict[str, type[BaseGalaxyAgent]] = {}
         self._agent_metadata: dict[str, dict] = {}
-        self._disabled: set[str] = set()
 
     def register(
         self,
@@ -68,8 +67,6 @@ def get_agent(self, agent_type: str, deps: GalaxyAgentDependencies) -> BaseGalax
         Raises:
             ValueError: If agent type is not registered
         """
-        if agent_type in self._disabled:
-            raise ValueError(f"Agent '{agent_type}' is disabled in configuration")
         if agent_type not in self._agents:
             available = list(self._agents.keys())
             raise ValueError(f"Unknown agent type: {agent_type}. Available: {available}")
@@ -149,11 +146,10 @@ def _is_enabled(agent_type: str) -> bool:
             return agent_cfg.get("enabled", True)
         return True
 
-    def _register_or_disable(registry: AgentRegistry, agent_type: str, agent_class: type[BaseGalaxyAgent]):
+    def _register_if_enabled(registry: AgentRegistry, agent_type: str, agent_class: type[BaseGalaxyAgent]):
         if _is_enabled(agent_type):
             registry.register(agent_type, agent_class)
         else:
-            registry._disabled.add(agent_type)
             log.info(f"Agent '{agent_type}' disabled by configuration, skipping registration")
 
     registry = AgentRegistry()
@@ -163,8 +159,8 @@ def _register_or_disable(registry: AgentRegistry, agent_type: str, agent_class:
         log.warning("Router agent cannot be disabled — ignoring enabled: false")
     registry.register(AgentType.ROUTER, QueryRouterAgent)
 
-    _register_or_disable(registry, AgentType.ERROR_ANALYSIS, ErrorAnalysisAgent)
-    _register_or_disable(registry, AgentType.CUSTOM_TOOL, CustomToolAgent)
-    _register_or_disable(registry, AgentType.ORCHESTRATOR, WorkflowOrchestratorAgent)
-    _register_or_disable(registry, AgentType.TOOL_RECOMMENDATION, ToolRecommendationAgent)
+    _register_if_enabled(registry, AgentType.ERROR_ANALYSIS, ErrorAnalysisAgent)
+    _register_if_enabled(registry, AgentType.CUSTOM_TOOL, CustomToolAgent)
+    _register_if_enabled(registry, AgentType.ORCHESTRATOR, WorkflowOrchestratorAgent)
+    _register_if_enabled(registry, AgentType.TOOL_RECOMMENDATION, ToolRecommendationAgent)
     return registry

lib/galaxy/managers/agents.py

@@ -10,7 +10,6 @@
 from galaxy.agents.registry import AgentRegistry
 from galaxy.agents.router import QueryRouterAgent
 from galaxy.config import GalaxyAppConfiguration
-from galaxy.exceptions import ConfigurationError
 from galaxy.managers.context import ProvidesUserContext
 from galaxy.managers.jobs import JobManager
 from galaxy.model import User
@@ -53,12 +52,6 @@ async def execute_agent(
         context: Optional[dict[str, Any]] = None,
     ) -> AgentResponse:
         """Execute a specific agent and return response."""
-        # Guard: reject disabled agents before attempting execution
-        inference_config = getattr(self.config, "inference_services", {}) or {}
-        agent_cfg = inference_config.get(agent_type, {})
-        if isinstance(agent_cfg, dict) and not agent_cfg.get("enabled", True):
-            raise ConfigurationError(f"Agent '{agent_type}' is disabled in configuration")
-
         deps = self.create_dependencies(trans, user)
 
         if context is None:

lib/galaxy/webapps/galaxy/api/agents.py

@@ -59,12 +59,7 @@ def list_agents(
         agents = []
         for agent_type in self.agent_service.list_agents():
             agent_info = self.agent_service.get_agent_info(agent_type)
-
-            # Disabled agents are already excluded from the registry,
-            # but double-check inference_services config here
             agent_config = inference_config.get(agent_type, {})
-            if isinstance(agent_config, dict) and not agent_config.get("enabled", True):
-                continue
 
             # Resolve model: agent-specific -> default -> global
             model = None

test/unit/app/test_agents.py

@@ -39,7 +39,6 @@
     QueryRouterAgent,
 )
 from galaxy.agents.registry import build_default_registry
-from galaxy.managers.agents import AgentService
 
 agent_registry = build_default_registry()
 from galaxy.agents.error_analysis import ErrorAnalysisResult
@@ -199,24 +198,12 @@ def test_build_registry_no_config_registers_all(self):
         registry = build_default_registry()
         assert len(registry.list_agents()) == 5
 
-    @pytest.mark.asyncio
-    async def test_disabled_agent_execution_raises(self):
-        """Executing a disabled agent should raise ConfigurationError."""
-        from galaxy.exceptions import ConfigurationError
-
-        config = mock.Mock()
-        config.inference_services = {"custom_tool": {"enabled": False}}
-        registry = build_default_registry(config)
-        service = AgentService(config, mock.Mock(), registry)
-        with pytest.raises(ConfigurationError, match="disabled"):
-            await service.execute_agent("custom_tool", "test", self.mock_trans, self.mock_user)
-
     def test_disabled_agent_registry_get_agent_raises(self):
-        """Registry.get_agent for a disabled agent gives a clear 'disabled' error."""
+        """Registry.get_agent for a disabled agent gives 'Unknown agent type' error."""
         config = mock.Mock()
         config.inference_services = {"custom_tool": {"enabled": False}}
         registry = build_default_registry(config)
-        with pytest.raises(ValueError, match="disabled"):
+        with pytest.raises(ValueError, match="Unknown agent type"):
             registry.get_agent("custom_tool", self.deps)
 
     def test_agent_registry(self):