Revert Agent(), Graph(), and Swarm() constructor modifications

- Remove config parameter integration from main constructors
- Revert Agent() constructor to original state without config parameter
- Revert Swarm() constructor to original state without config parameter
- Remove Graph() constructor config modifications
- Maintain ConfigLoader classes for direct programmatic use
- Preserve experimental config loader functionality
- Remove related unit tests for constructor config parameter
- Clean up constructor parameter handling logic

Author: vawsgit

src/strands/agent/agent.py

@@ -14,10 +14,8 @@
 import logging
 import random
 from concurrent.futures import ThreadPoolExecutor
-from pathlib import Path
-from typing import Any, AsyncGenerator, AsyncIterator, Callable, Dict, Mapping, Optional, Type, TypeVar, Union, cast
+from typing import Any, AsyncGenerator, AsyncIterator, Callable, Mapping, Optional, Type, TypeVar, Union, cast
 
-import yaml
 from opentelemetry import trace as trace_api
 from pydantic import BaseModel
 
@@ -200,8 +198,8 @@ def __init__(
             Union[Callable[..., Any], _DefaultCallbackHandlerSentinel]
         ] = _DEFAULT_CALLBACK_HANDLER,
         conversation_manager: Optional[ConversationManager] = None,
-        record_direct_tool_call: Optional[bool] = None,
-        load_tools_from_directory: Optional[bool] = None,
+        record_direct_tool_call: bool = True,
+        load_tools_from_directory: bool = False,
         trace_attributes: Optional[Mapping[str, AttributeValue]] = None,
         *,
         agent_id: Optional[str] = None,
@@ -210,7 +208,6 @@ def __init__(
         state: Optional[Union[AgentState, dict]] = None,
         hooks: Optional[list[HookProvider]] = None,
         session_manager: Optional[SessionManager] = None,
-        config: Optional[Union[str, Path, Dict[str, Any]]] = None,
     ):
         """Initialize the Agent with the specified configuration.
 
@@ -237,11 +234,9 @@ def __init__(
             conversation_manager: Manager for conversation history and context window.
                 Defaults to strands.agent.conversation_manager.SlidingWindowConversationManager if None.
             record_direct_tool_call: Whether to record direct tool calls in message history.
-                Defaults to True. When using config, this parameter only overrides the config value
-                if explicitly provided.
+                Defaults to True.
             load_tools_from_directory: Whether to load and automatically reload tools in the `./tools/` directory.
-                Defaults to False. When using config, this parameter only overrides the config value
-                if explicitly provided.
+                Defaults to False.
             trace_attributes: Custom trace attributes to apply to the agent's trace span.
             agent_id: Optional ID for the agent, useful for session management and multi-agent scenarios.
                 Defaults to "default".
@@ -255,108 +250,10 @@ def __init__(
                 Defaults to None.
             session_manager: Manager for handling agent sessions including conversation history and state.
                 If provided, enables session-based persistence and state management.
-            config: Configuration for initializing the agent from a file or dictionary.
-                Can be specified as:
-
-                - String: Path to a YAML (.yaml, .yml) or JSON (.json) configuration file
-                - Path: Path object to a YAML (.yaml, .yml) or JSON (.json) configuration file
-                - Dict: Configuration dictionary with agent parameters
-
-                When provided, the agent is initialized using the AgentConfigLoader with the specified
-                configuration. The config takes precedence over individual parameters, but individual
-                parameters can override config values when both are provided.
 
         Raises:
             ValueError: If agent id contains path separators.
-            FileNotFoundError: If config is a string/Path that doesn't exist.
-            ValueError: If config file format is not supported (must be .yaml, .yml, or .json).
         """
-        # Handle config-based initialization
-        if config is not None:
-            # Load configuration from file or use provided dict
-            config_dict = self._load_config(config)
-
-            # Handle both direct agent config and config with 'agent' key
-            if "agent" in config_dict:
-                agent_config = config_dict["agent"]
-            else:
-                agent_config = config_dict
-
-            # Import AgentConfigLoader here to avoid circular imports
-            from ..experimental.config_loader.agent import AgentConfigLoader
-
-            # Create agent from config and return early
-            config_loader = AgentConfigLoader()
-            configured_agent = config_loader.load_agent(agent_config)
-
-            # There is an odd mypy type discrepancy in this file for some reason
-            # There is a mismatch between src.strands.* and strands.*
-            # type/ignore annotations allow type checking to pass
-
-            # Override config values with any explicitly provided parameters
-            if model is not None:
-                configured_agent.model = (
-                    BedrockModel() if not model else BedrockModel(model_id=model) if isinstance(model, str) else model  # type: ignore
-                )
-            if messages is not None:
-                configured_agent.messages = messages
-            if tools is not None:
-                # Need to reinitialize tool registry with new tools
-                configured_agent.tool_registry = ToolRegistry()  # type: ignore
-                configured_agent.tool_registry.process_tools(tools)
-                configured_agent.tool_registry.initialize_tools(load_tools_from_directory)  # type: ignore
-            if system_prompt is not None:
-                configured_agent.system_prompt = system_prompt
-            if not isinstance(callback_handler, _DefaultCallbackHandlerSentinel):
-                if callback_handler is None:
-                    configured_agent.callback_handler = null_callback_handler
-                else:
-                    configured_agent.callback_handler = callback_handler
-            if conversation_manager is not None:
-                configured_agent.conversation_manager = conversation_manager  # type: ignore
-            if trace_attributes is not None:
-                configured_agent.trace_attributes = {}
-                for k, v in trace_attributes.items():
-                    if isinstance(v, (str, int, float, bool)) or (
-                        isinstance(v, list) and all(isinstance(x, (str, int, float, bool)) for x in v)
-                    ):
-                        configured_agent.trace_attributes[k] = v
-            if agent_id is not None:
-                configured_agent.agent_id = _identifier.validate(agent_id, _identifier.Identifier.AGENT)
-            if name is not None:
-                configured_agent.name = name
-            if description is not None:
-                configured_agent.description = description
-            if state is not None:
-                if isinstance(state, dict):
-                    configured_agent.state = AgentState(state)  # type: ignore
-                elif isinstance(state, AgentState):
-                    configured_agent.state = state  # type: ignore
-                else:
-                    raise ValueError("state must be an AgentState object or a dict")
-            if hooks is not None:
-                for hook in hooks:
-                    configured_agent.hooks.add_hook(hook)  # type: ignore
-            if session_manager is not None:
-                configured_agent._session_manager = session_manager  # type: ignore
-                configured_agent.hooks.add_hook(session_manager)  # type: ignore
-
-            # Override record_direct_tool_call and load_tools_from_directory only if explicitly provided
-            if record_direct_tool_call is not None:
-                configured_agent.record_direct_tool_call = record_direct_tool_call
-            if load_tools_from_directory is not None:
-                configured_agent.load_tools_from_directory = load_tools_from_directory
-                if load_tools_from_directory:
-                    if hasattr(configured_agent, "tool_watcher"):
-                        configured_agent.tool_watcher = ToolWatcher(tool_registry=configured_agent.tool_registry)  # type: ignore
-                    else:
-                        configured_agent.tool_watcher = ToolWatcher(tool_registry=configured_agent.tool_registry)  # type: ignore
-
-            # Copy all attributes from configured agent to self
-            self.__dict__.update(configured_agent.__dict__)
-            return
-
-        # Standard initialization when no config is provided
         self.model = BedrockModel() if not model else BedrockModel(model_id=model) if isinstance(model, str) else model
         self.messages = messages if messages is not None else []
 
@@ -387,8 +284,8 @@ def __init__(
                 ):
                     self.trace_attributes[k] = v
 
-        self.record_direct_tool_call = record_direct_tool_call if record_direct_tool_call is not None else True
-        self.load_tools_from_directory = load_tools_from_directory if load_tools_from_directory is not None else False
+        self.record_direct_tool_call = record_direct_tool_call
+        self.load_tools_from_directory = load_tools_from_directory
 
         self.tool_registry = ToolRegistry()
 
@@ -432,42 +329,6 @@ def __init__(
                 self.hooks.add_hook(hook)
         self.hooks.invoke_callbacks(AgentInitializedEvent(agent=self))
 
-    def _load_config(self, config: Union[str, Path, Dict[str, Any]]) -> Dict[str, Any]:
-        """Load configuration from file or return provided dictionary.
-
-        Args:
-            config: Either a file path (string or Path), or configuration dictionary
-
-        Returns:
-            Configuration dictionary
-
-        Raises:
-            FileNotFoundError: If config is a string/Path that doesn't exist
-            ValueError: If config file format is not supported
-        """
-        if isinstance(config, dict):
-            return config
-
-        # Handle both str and Path objects
-        if isinstance(config, (str, Path)):
-            config_path = Path(config)
-
-            if not config_path.exists():
-                raise FileNotFoundError(f"Configuration file not found: {config}")
-
-            suffix = config_path.suffix.lower()
-
-            if suffix in [".yaml", ".yml"]:
-                with open(config_path, "r", encoding="utf-8") as f:
-                    return dict[str, Any](yaml.safe_load(f))
-            elif suffix == ".json":
-                with open(config_path, "r", encoding="utf-8") as f:
-                    return dict[str, Any](json.load(f))
-            else:
-                raise ValueError(f"Unsupported config file format: {suffix}. Supported formats: .yaml, .yml, .json")
-
-        raise ValueError(f"Config must be a string (file path), Path object, or dictionary, got: {type(config)}")
-
     @property
     def tool(self) -> ToolCaller:
         """Call tool as a function.
@@ -859,4 +720,4 @@ def _end_agent_trace_span(
     def _append_message(self, message: Message) -> None:
         """Appends a message to the agent's list of messages and invokes the callbacks for the MessageCreatedEvent."""
         self.messages.append(message)
-        self.hooks.invoke_callbacks(MessageAddedEvent(agent=self, message=message))
+        self.hooks.invoke_callbacks(MessageAddedEvent(agent=self, message=message))

src/strands/multiagent/graph.py

@@ -16,13 +16,11 @@
 
 import asyncio
 import copy
-import json
 import logging
 import time
 from concurrent.futures import ThreadPoolExecutor
 from dataclasses import dataclass, field
-from pathlib import Path
-from typing import Any, Callable, Dict, Optional, Tuple, Union
+from typing import Any, Callable, Optional, Tuple
 
 from opentelemetry import trace as trace_api
 
@@ -223,100 +221,6 @@ def __init__(self) -> None:
         self._node_timeout: Optional[float] = None
         self._reset_on_revisit: bool = False
 
-    @classmethod
-    def from_config(cls, config: Union[str, Path, Dict[str, Any]]) -> "GraphBuilder":
-        """Create a GraphBuilder from YAML/JSON configuration.
-
-        Args:
-            config: Configuration source. Can be:
-                   - String: Path to YAML (.yaml, .yml) or JSON (.json) file
-                   - Path: Path object to configuration file
-                   - Dict: Configuration dictionary
-
-        Returns:
-            GraphBuilder instance pre-configured with nodes, edges, and settings
-
-        Example:
-            # From file
-            builder = GraphBuilder.from_config("workflow.yaml")
-            graph = builder.build()
-
-            # From dictionary
-            config = {...}
-            builder = GraphBuilder.from_config(config)
-
-            # Can still modify after loading
-            builder.add_node(additional_agent, "extra_node")
-            builder.set_max_node_executions(100)
-            graph = builder.build()
-        """
-        # Load and validate configuration
-        if isinstance(config, (str, Path)):
-            config_dict = cls._load_config_file(config)
-        else:
-            config_dict = config
-
-        # Handle both direct graph config and config with 'graph' key
-        if "graph" in config_dict:
-            graph_config = config_dict["graph"]
-        else:
-            graph_config = config_dict
-
-        # Use GraphConfigLoader to populate builder
-        from ..experimental.config_loader.graph import GraphConfigLoader
-
-        loader = GraphConfigLoader()
-        builder = cls()
-
-        # Validate configuration structure
-        loader._validate_config(graph_config)
-
-        # Load nodes using existing loaders
-        if "nodes" in graph_config:
-            nodes = loader._load_nodes(graph_config["nodes"])
-            for node_id, node in nodes.items():
-                builder.nodes[node_id] = node  # type: ignore
-
-        # Load edges with conditions
-        if "edges" in graph_config:
-            edges = loader._load_edges(graph_config["edges"], builder.nodes)  # type: ignore
-            builder.edges = edges  # type: ignore
-
-        # Load entry points
-        if "entry_points" in graph_config:
-            for entry_point_id in graph_config["entry_points"]:
-                if entry_point_id in builder.nodes:
-                    builder.entry_points.add(builder.nodes[entry_point_id])
-
-        # Load execution configuration
-        if "max_node_executions" in graph_config:
-            builder._max_node_executions = graph_config["max_node_executions"]
-        if "execution_timeout" in graph_config:
-            builder._execution_timeout = graph_config["execution_timeout"]
-        if "node_timeout" in graph_config:
-            builder._node_timeout = graph_config["node_timeout"]
-        if "reset_on_revisit" in graph_config:
-            builder._reset_on_revisit = graph_config["reset_on_revisit"]
-
-        return builder
-
-    @staticmethod
-    def _load_config_file(config_path: Union[str, Path]) -> Dict[str, Any]:
-        """Load configuration from YAML or JSON file."""
-        import yaml
-
-        path = Path(config_path)
-        if not path.exists():
-            raise FileNotFoundError(f"Configuration file not found: {config_path}")
-
-        with open(path, "r") as f:
-            if path.suffix.lower() in [".yaml", ".yml"]:
-                return dict[str, Any](yaml.safe_load(f))
-            elif path.suffix.lower() == ".json":
-                return dict[str, Any](json.load(f))
-            else:
-                raise ValueError(f"Unsupported config file format: {path.suffix}")
-
     def add_node(self, executor: Agent | MultiAgentBase, node_id: str | None = None) -> GraphNode:
         """Add an Agent or MultiAgentBase instance as a node to the graph."""
         _validate_node_executor(executor, self.nodes)
@@ -812,4 +716,4 @@ def _build_result(self) -> GraphResult:
             execution_order=self.state.execution_order,
             edges=self.state.edges,
             entry_points=self.state.entry_points,
-        )
+        )