feat: enhance AgentConfig with ToolPool integration and tool validation

- Add optional ToolPool parameter to AgentConfig constructor
- Implement tool selection from ToolPool when 'tools' specified in config
- Add validation to ensure tool names exist in provided ToolPool
- Raise ValueError if tools specified without ToolPool
- Move ToolPool import to top of file for cleaner imports
- Add comprehensive tests for new functionality
- Fix existing tests to work with new validation logic

🤖 Assisted by Amazon Q Developer

Author: mrlee-amazon

src/strands/experimental/agent_config.py

@@ -4,15 +4,18 @@
 
 import json
 
+from .tool_pool import ToolPool
+
 
 class AgentConfig:
     """Agent configuration with toAgent() method and ToolPool integration."""
 
-    def __init__(self, config_source: str | dict[str, any]):
+    def __init__(self, config_source: str | dict[str, any], tool_pool: "ToolPool | None" = None):
         """Initialize AgentConfig from file path or dictionary.
         
         Args:
             config_source: Path to JSON config file (must start with 'file://') or config dictionary
+            tool_pool: Optional ToolPool to select tools from when 'tools' is specified in config
         """
         if isinstance(config_source, str):
             # Require file:// prefix for file paths
@@ -28,12 +31,34 @@ def __init__(self, config_source: str | dict[str, any]):
             config_data = config_source
 
         self.model = config_data.get('model')
-        self.tools = config_data.get('tools')
         self.system_prompt = config_data.get('prompt')  # Only accept 'prompt' key
 
-        # Create empty default ToolPool
-        from .tool_pool import ToolPool
-        self._tool_pool = ToolPool()
+        # Handle tool selection from ToolPool
+        if tool_pool is not None:
+            self._tool_pool = tool_pool
+        else:
+            self._tool_pool = ToolPool()
+            
+        # Process tools configuration if provided
+        config_tools = config_data.get('tools')
+        if config_tools is not None:
+            if tool_pool is None:
+                raise ValueError("Tool names specified in config but no ToolPool provided")
+            
+            # Validate all tool names exist in the ToolPool
+            available_tools = tool_pool.list_tool_names()
+            for tool_name in config_tools:
+                if tool_name not in available_tools:
+                    raise ValueError(f"Tool '{tool_name}' not found in ToolPool. Available tools: {available_tools}")
+            
+            # Create new ToolPool with only selected tools
+            selected_pool = ToolPool()
+            all_tools = tool_pool.get_tools()
+            for tool in all_tools:
+                if tool.tool_name in config_tools:
+                    selected_pool.add_tool(tool)
+            
+            self._tool_pool = selected_pool
 
     @property
     def tool_pool(self) -> "ToolPool":

tests/strands/experimental/test_agent_config.py

@@ -7,6 +7,7 @@
 
 from strands.experimental.agent_config import AgentConfig
 from strands.experimental.tool_pool import ToolPool
+from strands.types.tools import AgentTool
 
 
 class TestAgentConfig:
@@ -18,16 +19,14 @@ def test_agent_config_creation(self):
         assert config.model == "test-model"
 
     def test_agent_config_with_tools(self):
-        """Test AgentConfig with tools configuration."""
+        """Test AgentConfig with basic configuration."""
 
         config = AgentConfig({
             "model": "test-model",
-            "tools": ["tool1", "tool2"],
             "prompt": "Test prompt"
         })
 
         assert config.model == "test-model"
-        assert config.tools == ["tool1", "tool2"]
         assert config.system_prompt == "Test prompt"
 
     def test_agent_config_file_prefix_required(self):
@@ -68,7 +67,6 @@ def test_to_agent_calls_agent_constructor(self, mock_agent):
 
         config = AgentConfig({
             "model": "test-model",
-            "tools": ["tool1"],
             "prompt": "Test prompt"
         })
 
@@ -112,3 +110,80 @@ def test_to_agent_with_tool_pool_parameter(self, mock_agent):
         mock_agent.assert_called_once()
         call_args = mock_agent.call_args[1]
         assert 'tools' in call_args
+    
+    def test_agent_config_with_tool_pool_constructor(self):
+        """Test AgentConfig with ToolPool parameter in constructor."""
+        # Create mock tools
+        class MockTool(AgentTool):
+            def __init__(self, name):
+                self._name = name
+            
+            @property
+            def tool_name(self):
+                return self._name
+            
+            @property
+            def tool_type(self):
+                return "mock"
+            
+            @property
+            def tool_spec(self):
+                return {"name": self._name, "type": "mock"}
+            
+            def stream(self, input_data, context):
+                return iter([])
+        
+        tool1 = MockTool("calculator")
+        tool2 = MockTool("web_search")
+        
+        # Create ToolPool with tools
+        pool = ToolPool([tool1, tool2])
+        
+        # Create config with tool selection
+        config = AgentConfig({
+            "model": "test-model",
+            "prompt": "Test prompt",
+            "tools": ["calculator"]
+        }, tool_pool=pool)
+        
+        # Should have selected only calculator
+        assert config.tool_pool.list_tool_names() == ["calculator"]
+    
+    def test_agent_config_tool_validation_error(self):
+        """Test that invalid tool names raise validation error."""
+        class MockTool(AgentTool):
+            def __init__(self, name):
+                self._name = name
+            
+            @property
+            def tool_name(self):
+                return self._name
+            
+            @property
+            def tool_type(self):
+                return "mock"
+            
+            @property
+            def tool_spec(self):
+                return {"name": self._name, "type": "mock"}
+            
+            def stream(self, input_data, context):
+                return iter([])
+        
+        tool1 = MockTool("calculator")
+        pool = ToolPool([tool1])
+        
+        # Should raise error for unknown tool
+        with pytest.raises(ValueError, match="Tool 'unknown_tool' not found in ToolPool"):
+            AgentConfig({
+                "model": "test-model",
+                "tools": ["unknown_tool"]
+            }, tool_pool=pool)
+    
+    def test_agent_config_tools_without_pool_error(self):
+        """Test that specifying tools without ToolPool raises error."""
+        with pytest.raises(ValueError, match="Tool names specified in config but no ToolPool provided"):
+            AgentConfig({
+                "model": "test-model",
+                "tools": ["calculator"]
+            })