open-swarm 0.1.1744937124__py3-none-any.whl → 0.1.1744942852__py3-none-any.whl

swarm/extensions/blueprint/blueprint_base.py

@@ -1,333 +0,0 @@
-# --- REMOVE noisy debug/framework prints unless SWARM_DEBUG=1 ---
-import os
-
-def _should_debug():
-    return os.environ.get("SWARM_DEBUG") == "1"
-
-def _debug_print(*args, **kwargs):
-    if _should_debug():
-        print(*args, **kwargs)
-
-def _framework_print(*args, **kwargs):
-    if _should_debug():
-        print(*args, **kwargs)
-
-# --- Content for src/swarm/extensions/blueprint/blueprint_base.py ---
-import logging
-import json
-from abc import ABC, abstractmethod
-from typing import Dict, Any, Optional, List, AsyncGenerator
-from pathlib import Path
-from django.apps import apps # Import Django apps registry
-
-# Keep the function import
-from swarm.extensions.config.config_loader import get_profile_from_config, _substitute_env_vars
-
-from openai import AsyncOpenAI
-from agents import set_default_openai_client
-from .slash_commands import slash_registry, SlashCommandRegistry
-from blueprint_agents import *  # Import all from blueprint_agents
-
-logger = logging.getLogger(__name__)
-from rich.console import Console
-import traceback
-
-# --- PATCH: Suppress OpenAI tracing/telemetry errors if using LiteLLM/custom endpoint ---
-import logging
-import os
-if os.environ.get("LITELLM_BASE_URL") or os.environ.get("OPENAI_BASE_URL"):
-    # Silence openai.agents tracing/telemetry errors
-    logging.getLogger("openai.agents").setLevel(logging.CRITICAL)
-    try:
-        import openai.agents.tracing
-        openai.agents.tracing.TracingClient = lambda *a, **kw: None
-    except Exception:
-        pass
-
-# --- Spinner/Status Message Enhancements ---
-# To be used by all blueprints for consistent UX
-import itertools
-import sys
-import threading
-import time
-
-class Spinner:
-    def __init__(self, message_sequence=None, interval=0.3, slow_threshold=10):
-        self.message_sequence = message_sequence or ['Generating.', 'Generating..', 'Generating...', 'Running...']
-        self.interval = interval
-        self.slow_threshold = slow_threshold  # seconds before 'Taking longer than expected'
-        self._stop_event = threading.Event()
-        self._thread = None
-        self._start_time = None
-
-    def start(self):
-        self._stop_event.clear()
-        self._start_time = time.time()
-        self._thread = threading.Thread(target=self._spin)
-        self._thread.start()
-
-    def _spin(self):
-        for msg in itertools.cycle(self.message_sequence):
-            if self._stop_event.is_set():
-                break
-            elapsed = time.time() - self._start_time
-            if elapsed > self.slow_threshold:
-                sys.stdout.write('\rGenerating... Taking longer than expected   ')
-            else:
-                sys.stdout.write(f'\r{msg}   ')
-            sys.stdout.flush()
-            time.sleep(self.interval)
-        sys.stdout.write('\r')
-        sys.stdout.flush()
-
-    def stop(self, final_message=''):
-        self._stop_event.set()
-        if self._thread:
-            self._thread.join()
-        if final_message:
-            sys.stdout.write(f'\r{final_message}\n')
-            sys.stdout.flush()
-
-# Usage Example (to be called in blueprints):
-# spinner = Spinner()
-# spinner.start()
-# ... do work ...
-# spinner.stop('Done!')
-
-def configure_openai_client_from_env():
-    """
-    Framework-level function: Always instantiate and set the default OpenAI client.
-    Prints out the config being used for debug.
-    """
-    import os
-    from agents import set_default_openai_client
-    from openai import AsyncOpenAI
-    base_url = os.environ.get("LITELLM_BASE_URL") or os.environ.get("OPENAI_BASE_URL")
-    api_key = os.environ.get("LITELLM_API_KEY") or os.environ.get("OPENAI_API_KEY")
-    _debug_print(f"[DEBUG] Using OpenAI client config: base_url={base_url}, api_key={'set' if api_key else 'NOT SET'}")
-    if base_url and api_key:
-        client = AsyncOpenAI(base_url=base_url, api_key=api_key)
-        set_default_openai_client(client)
-        _framework_print(f"[FRAMEWORK] Set default OpenAI client: base_url={base_url}, api_key={'set' if api_key else 'NOT SET'}")
-    else:
-        _framework_print("[FRAMEWORK] WARNING: base_url or api_key missing, OpenAI client not set!")
-
-configure_openai_client_from_env()
-
-class BlueprintBase(ABC):
-    """
-    Abstract base class for all Swarm blueprints.
-
-    Defines the core interface for blueprint initialization and execution.
-    """
-    enable_terminal_commands: bool = False  # By default, terminal command execution is disabled
-
-    @classmethod
-    def main(cls):
-        """
-        Standard CLI entry point for all blueprints.
-        Subclasses can override metadata/config_path if needed.
-        """
-        from swarm.extensions.blueprint.cli_handler import run_blueprint_cli
-        from pathlib import Path
-        swarm_version = getattr(cls, "SWARM_VERSION", "1.0.0")
-        config_path = getattr(cls, "DEFAULT_CONFIG_PATH", Path(__file__).parent / "swarm_config.json")
-        run_blueprint_cli(cls, swarm_version=swarm_version, default_config_path=config_path)
-
-    def display_splash_screen(self, animated: bool = False):
-        """Default splash screen. Subclasses can override for custom CLI/API branding."""
-        console = Console()
-        console.print(f"[bold cyan]Welcome to {self.__class__.__name__}![/]", style="bold")
-
-    def __init__(self, blueprint_id: str, config_path: Optional[Path] = None, enable_terminal_commands: Optional[bool] = None):
-        try:
-            if not blueprint_id:
-                raise ValueError("blueprint_id cannot be empty or None")
-            self.blueprint_id = blueprint_id
-            self.config_path = config_path # Note: config_path is currently unused if we rely on AppConfig
-            self._config: Optional[Dict[str, Any]] = None
-            self._llm_profile_name: Optional[str] = None
-            self._llm_profile_data: Optional[Dict[str, Any]] = None
-            self._markdown_output: bool = True # Default
-            # Allow per-instance override
-            if enable_terminal_commands is not None:
-                self.enable_terminal_commands = enable_terminal_commands
-            # Else: use class attribute (default False or set by subclass)
-
-            logger.info(f"Initializing blueprint '{self.blueprint_id}' (Type: {self.__class__.__name__})")
-            
-            # --- Ensure custom OpenAI client for custom LLM providers ---
-            import os
-
-            # Remove monkey patching and envvar hacks. Always pass config values directly.
-            # (Retain only explicit AsyncOpenAI client instantiation in blueprints)
-            # (No changes needed here for direct client pattern)
-
-            self._load_and_process_config()
-        except AttributeError as e:
-            logger.debug(f"[BlueprintBase.__init__] AttributeError: {e}")
-            traceback.print_exc()
-            raise
-
-    def _load_and_process_config(self):
-        """Loads the main Swarm config and extracts relevant settings. Falls back to empty config if Django unavailable or not found."""
-        import os
-        import json
-        from pathlib import Path
-        def redact(val):
-            if not isinstance(val, str) or len(val) <= 4:
-                return "****"
-            return val[:2] + "*" * (len(val)-4) + val[-2:]
-        def redact_dict(d):
-            if isinstance(d, dict):
-                return {k: (redact_dict(v) if not (isinstance(v, str) and ("key" in k.lower() or "token" in k.lower() or "secret" in k.lower())) else redact(v)) for k, v in d.items()}
-            elif isinstance(d, list):
-                return [redact_dict(item) for item in d]
-            return d
-        try:
-            try:
-                # --- Get config from the AppConfig instance (Django) ---
-                app_config_instance = apps.get_app_config('swarm')
-                if not hasattr(app_config_instance, 'config') or not app_config_instance.config:
-                    raise ValueError("AppConfig for 'swarm' does not have a valid 'config' attribute.")
-                config = app_config_instance.config
-                logger.debug("Loaded config from Django AppConfig.")
-            except Exception as e:
-                if _should_debug():
-                    logger.warning(f"Falling back to CLI/home config due to error: {e}")
-                config = None
-                # 1. CLI argument (not handled here, handled in cli_handler)
-                # 2. Current working directory
-                cwd_config = Path.cwd() / "swarm_config.json"
-                if cwd_config.exists():
-                    with open(cwd_config, 'r') as f:
-                        config = json.load(f)
-                # 3. XDG_CONFIG_HOME or ~/.config/swarm/swarm_config.json
-                elif os.environ.get("XDG_CONFIG_HOME"):
-                    xdg_config = Path(os.environ["XDG_CONFIG_HOME"]) / "swarm" / "swarm_config.json"
-                    if xdg_config.exists():
-                        with open(xdg_config, 'r') as f:
-                            config = json.load(f)
-                elif (Path.home() / ".config/swarm/swarm_config.json").exists():
-                    with open(Path.home() / ".config/swarm/swarm_config.json", 'r') as f:
-                        config = json.load(f)
-                # 4. Legacy fallback: ~/.swarm/swarm_config.json
-                elif (Path.home() / ".swarm/swarm_config.json").exists():
-                    with open(Path.home() / ".swarm/swarm_config.json", 'r') as f:
-                        config = json.load(f)
-                # 5. Fallback: OPENAI_API_KEY envvar
-                elif os.environ.get("OPENAI_API_KEY"):
-                    config = {
-                        "llm": {"default": {"provider": "openai", "model": "gpt-3.5-turbo", "api_key": os.environ["OPENAI_API_KEY"]}},
-                        "settings": {"default_llm_profile": "default", "default_markdown_output": True},
-                        "blueprints": {},
-                        "llm_profile": "default",
-                        "mcpServers": {}
-                    }
-                    logger.info("No config file found, using default config with OPENAI_API_KEY for CLI mode.")
-                else:
-                    config = {}
-                    logger.warning("No config file found and OPENAI_API_KEY is not set. Using empty config. CLI blueprints may fail if LLM config is required.")
-                if config is not None:
-                    config = _substitute_env_vars(config)
-                self._config = config or {}
-
-            # --- After config is loaded, set OpenAI client from config if possible ---
-            try:
-                llm_profiles = self._config.get("llm", {})
-                default_profile = llm_profiles.get("default", {})
-                base_url = default_profile.get("base_url")
-                api_key = default_profile.get("api_key")
-                # Expand env vars if present
-                import os
-                if base_url and base_url.startswith("${"):
-                    var = base_url[2:-1]
-                    base_url = os.environ.get(var, base_url)
-                if api_key and api_key.startswith("${"):
-                    var = api_key[2:-1]
-                    api_key = os.environ.get(var, api_key)
-                if base_url and api_key:
-                    from openai import AsyncOpenAI
-                    from agents import set_default_openai_client
-                    _debug_print(f"[DEBUG] (config) Setting OpenAI client: base_url={base_url}, api_key={'set' if api_key else 'NOT SET'}")
-                    client = AsyncOpenAI(base_url=base_url, api_key=api_key)
-                    set_default_openai_client(client)
-            except Exception as e:
-                _debug_print(f"[DEBUG] Failed to set OpenAI client from config: {e}")
-
-            # --- Debug: Print and log redacted config ---
-            redacted_config = redact_dict(self._config)
-            logger.debug(f"Loaded config (redacted): {json.dumps(redacted_config, indent=2)}")
-
-            # --- Process LLM profile name and data ---
-            settings_section = self._config.get("settings", {})
-            llm_section = self._config.get("llm", {})
-            default_profile = settings_section.get("default_llm_profile") or "default"
-            self._llm_profile_name = self._config.get("llm_profile") or default_profile
-            if "profiles" in llm_section:
-                self._llm_profile_data = llm_section["profiles"].get(self._llm_profile_name, {})
-            else:
-                self._llm_profile_data = llm_section.get(self._llm_profile_name, {})
-
-            blueprint_specific_settings = self._config.get("blueprints", {}).get(self.blueprint_id, {})
-            global_markdown_setting = settings_section.get("default_markdown_output", True)
-            self._markdown_output = blueprint_specific_settings.get("markdown_output", global_markdown_setting)
-            logger.debug(f"Markdown output for '{self.blueprint_id}': {self._markdown_output}")
-
-        except ValueError as e:
-            logger.error(f"Configuration error for blueprint '{self.blueprint_id}': {e}", exc_info=True)
-            raise
-        except Exception as e:
-            logger.error(f"Unexpected error loading config for blueprint '{self.blueprint_id}': {e}", exc_info=True)
-            raise
-
-    @property
-    def config(self) -> Dict[str, Any]:
-        """Returns the loaded and processed Swarm configuration."""
-        if self._config is None:
-            raise RuntimeError("Configuration accessed before initialization or after failure.")
-        return self._config
-
-    @property
-    def llm_profile(self) -> Dict[str, Any]:
-        """Returns the loaded and processed LLM profile data for this blueprint."""
-        if self._llm_profile_data is None:
-            raise RuntimeError("LLM profile accessed before initialization or after failure.")
-        return self._llm_profile_data
-
-    @property
-    def llm_profile_name(self) -> str:
-        """Returns the name of the LLM profile being used."""
-        if self._llm_profile_name is None:
-             raise RuntimeError("LLM profile name accessed before initialization or after failure.")
-        return self._llm_profile_name
-
-    @property
-    def slash_commands(self) -> SlashCommandRegistry:
-        """Access the global slash command registry. Blueprints can register new commands here."""
-        return slash_registry
-
-    def get_llm_profile(self, profile_name: str) -> dict:
-        """Returns the LLM profile dict for the given profile name from config, or empty dict if not found.
-        Supports both llm.profiles and direct llm keys for backward compatibility."""
-        llm_section = self.config.get("llm", {})
-        if "profiles" in llm_section:
-            return llm_section["profiles"].get(profile_name, {})
-        return llm_section.get(profile_name, {})
-
-    @property
-    def should_output_markdown(self) -> bool:
-        """Returns whether the blueprint should format output as Markdown."""
-        return self._markdown_output
-
-    @abstractmethod
-    async def run(self, messages: List[Dict[str, Any]], **kwargs: Any) -> AsyncGenerator[Dict[str, Any], None]:
-        """
-        The main execution method for the blueprint.
-        """
-        import os
-        import pprint
-        logger.debug("ENVIRONMENT DUMP BEFORE MODEL CALL:")
-        pprint.pprint(dict(os.environ))
-        raise NotImplementedError("Subclasses must implement the 'run' method.")
-        yield {}

swarm/extensions/blueprint/blueprint_discovery.py

@@ -1,128 +0,0 @@
-import os
-import importlib
-import importlib.util
-import inspect
-import logging # Ensure logging is imported
-import sys
-from typing import Dict, Type, Any
-from pathlib import Path
-
-# *** Define logger EARLIER ***
-logger = logging.getLogger(__name__)
-
-# *** Import the ACTUAL BlueprintBase from the likely correct path ***
-try:
-    # Adjust this path if BlueprintBase lives elsewhere
-    from swarm.extensions.blueprint.blueprint_base import BlueprintBase
-except ImportError:
-    # This logger call is now safe
-    logger.error("Failed to import BlueprintBase from swarm.extensions.blueprint.blueprint_base. Using placeholder.", exc_info=True)
-    class BlueprintBase: # Fallback placeholder
-        metadata: Dict[str, Any] = {}
-        def __init__(self, *args, **kwargs): pass
-        async def run(self, *args, **kwargs): pass
-
-
-class BlueprintLoadError(Exception):
-    """Custom exception for errors during blueprint loading."""
-    pass
-
-def _get_blueprint_name_from_dir(dir_name: str) -> str:
-    """Converts directory name (e.g., 'blueprint_my_agent') to blueprint name (e.g., 'my_agent')."""
-    prefix = "blueprint_"
-    if dir_name.startswith(prefix):
-        return dir_name[len(prefix):]
-    return dir_name
-
-def discover_blueprints(blueprint_dir: str) -> Dict[str, Type[BlueprintBase]]:
-    """
-    Discovers blueprints (subclasses of BlueprintBase) by looking for
-    'blueprint_{name}.py' files within subdirectories of the given blueprint directory.
-
-    Args:
-        blueprint_dir: The path to the directory containing blueprint subdirectories.
-
-    Returns:
-        A dictionary mapping blueprint names to their corresponding class objects.
-    """
-    logger.info(f"Starting blueprint discovery in directory: {blueprint_dir}")
-    blueprints: Dict[str, Type[BlueprintBase]] = {}
-    base_dir = Path(blueprint_dir).resolve()
-
-    if not base_dir.is_dir():
-        logger.error(f"Blueprint directory not found or is not a directory: {base_dir}")
-        return blueprints
-
-    # Iterate over items inside the base blueprint directory
-    for subdir in base_dir.iterdir():
-        if not subdir.is_dir():
-            continue # Skip files directly under blueprints/
-
-        # Use directory name as blueprint name (e.g., 'echocraft')
-        blueprint_name = subdir.name
-        logger.debug(f"Processing potential blueprint '{blueprint_name}' in directory: {subdir.name}")
-
-        # Look for the specific .py file, e.g., blueprint_echocraft.py
-        py_file_name = f"blueprint_{blueprint_name}.py"
-        py_file_path = subdir / py_file_name
-
-        if not py_file_path.is_file():
-            # Also check for just {blueprint_name}.py if that's a convention
-            alt_py_file_name = f"{blueprint_name}.py"
-            alt_py_file_path = subdir / alt_py_file_name
-            if alt_py_file_path.is_file():
-                 py_file_path = alt_py_file_path # Use the alternative path
-                 py_file_name = alt_py_file_name
-                 logger.debug(f"Found alternative blueprint file: {py_file_name}")
-            else:
-                 logger.warning(f"Skipping directory '{subdir.name}': Neither '{py_file_name}' nor '{alt_py_file_name}' found.")
-                 continue
-
-
-        # Construct module import path, e.g., blueprints.echocraft.blueprint_echocraft
-        if py_file_path.name.startswith('blueprint_gatcha'):
-            module_import_path = f"swarm.blueprints.gatcha.{py_file_path.stem}"
-        elif py_file_path.name.startswith('blueprint_'):
-            module_import_path = f"swarm.blueprints.{subdir.name}.{py_file_path.stem}"
-        else:
-            continue
-
-        try:
-            # Ensure parent directory is in path
-            parent_dir = str(base_dir.parent)
-            if parent_dir not in sys.path:
-                 logger.debug(f"Adding '{parent_dir}' to sys.path for blueprint discovery.")
-                 sys.path.insert(0, parent_dir)
-
-            # Create module spec from file path
-            module_spec = importlib.util.spec_from_file_location(module_import_path, py_file_path)
-
-            if module_spec and module_spec.loader:
-                module = importlib.util.module_from_spec(module_spec)
-                sys.modules[module_import_path] = module
-                module_spec.loader.exec_module(module)
-                logger.debug(f"Successfully loaded module: {module_import_path}")
-
-                found_bp_class = None
-                for name, obj in inspect.getmembers(module):
-                    if inspect.isclass(obj) and obj.__module__ == module_import_path and issubclass(obj, BlueprintBase) and obj is not BlueprintBase:
-                        if found_bp_class:
-                            logger.warning(f"Multiple BlueprintBase subclasses found in {py_file_name}. Using the first: {found_bp_class.__name__}.")
-                        else:
-                            logger.debug(f"Found Blueprint class '{name}' in module '{module_import_path}'")
-                            found_bp_class = obj
-                            blueprints[blueprint_name] = found_bp_class
-                            # break
-
-                if not found_bp_class:
-                    logger.warning(f"No BlueprintBase subclass found directly defined in module: {module_import_path}")
-            else:
-                logger.warning(f"Could not create module spec for {py_file_path}")
-
-        except Exception as e:
-            logger.error(f"Error processing blueprint file '{py_file_path}': {e}", exc_info=True)
-            if module_import_path in sys.modules:
-                 del sys.modules[module_import_path]
-
-    logger.info(f"Blueprint discovery complete. Found: {list(blueprints.keys())}")
-    return blueprints

swarm/extensions/blueprint/blueprint_utils.py

@@ -1,17 +0,0 @@
-"""
-Utility functions for blueprint management.
-"""
-
-def filter_blueprints(all_blueprints: dict, allowed_blueprints_str: str) -> dict:
-    """
-    Filters the given blueprints dictionary using a comma-separated string of allowed blueprint keys.
-
-    Args:
-        all_blueprints (dict): A dictionary containing all discovered blueprints.
-        allowed_blueprints_str (str): A comma-separated string of allowed blueprint keys.
-
-    Returns:
-        dict: A dictionary containing only the blueprints whose keys are present in the allowed list.
-    """
-    allowed_list = [bp.strip() for bp in allowed_blueprints_str.split(",")]
-    return {k: v for k, v in all_blueprints.items() if k in allowed_list}

swarm/extensions/blueprint/common_utils.py

@@ -1,12 +0,0 @@
-"""
-Common utilities potentially shared across blueprint extensions.
-"""
-
-from typing import Any # Removed Dict, List as they weren't used
-
-def get_agent_name(agent: Any) -> str:
-    """Return the name of an agent from its attributes ('name' or '__name__')."""
-    return getattr(agent, "name", getattr(agent, "__name__", "<unknown>"))
-
-# get_token_count has been moved to swarm.utils.context_utils
-# Ensure imports in other files point to the correct location.

swarm/extensions/blueprint/config_loader.py

@@ -1,122 +0,0 @@
-import json
-import logging
-import os
-from pathlib import Path
-from typing import Any, Dict, Optional, Union
-
-from dotenv import load_dotenv
-
-logger = logging.getLogger("swarm.config")
-
-def _substitute_env_vars(value: Any) -> Any:
-    """Recursively substitute environment variables in strings, lists, and dicts."""
-    if isinstance(value, str):
-        return os.path.expandvars(value)
-    elif isinstance(value, list):
-        return [_substitute_env_vars(item) for item in value]
-    elif isinstance(value, dict):
-        return {k: _substitute_env_vars(v) for k, v in value.items()}
-    else:
-        return value
-
-def load_environment(project_root: Path):
-    """Loads environment variables from a `.env` file located at the project root."""
-    dotenv_path = project_root / ".env"
-    logger.debug(f"Checking for .env file at: {dotenv_path}")
-    try:
-        if dotenv_path.is_file():
-            loaded = load_dotenv(dotenv_path=dotenv_path, override=True)
-            if loaded:
-                logger.debug(f".env file Loaded/Overridden at: {dotenv_path}")
-        else:
-            logger.debug(f"No .env file found at {dotenv_path}.")
-    except Exception as e:
-        logger.error(f"Error loading .env file '{dotenv_path}': {e}", exc_info=logger.level <= logging.DEBUG)
-
-def load_full_configuration(
-    blueprint_class_name: str,
-    default_config_path: Path,
-    config_path_override: Optional[Union[str, Path]] = None,
-    profile_override: Optional[str] = None,
-    cli_config_overrides: Optional[Dict[str, Any]] = None,
-) -> Dict[str, Any]:
-    """
-    Loads and merges configuration settings from base file, blueprint specifics, profiles, and CLI overrides.
-
-    Args:
-        blueprint_class_name (str): The name of the blueprint class (e.g., "MyBlueprint").
-        default_config_path (Path): The default path to the swarm_config.json file.
-        config_path_override (Optional[Union[str, Path]]): Path specified via CLI argument.
-        profile_override (Optional[str]): Profile specified via CLI argument.
-        cli_config_overrides (Optional[Dict[str, Any]]): Overrides provided via CLI argument.
-
-    Returns:
-        Dict[str, Any]: The final, merged configuration dictionary.
-
-    Raises:
-        ValueError: If the configuration file has JSON errors or cannot be read.
-        FileNotFoundError: If a specific config_path_override is given but the file doesn't exist.
-    """
-    config_path = Path(config_path_override) if config_path_override else default_config_path
-    logger.debug(f"Attempting to load base configuration from: {config_path}")
-    base_config = {}
-    if config_path.is_file():
-        try:
-            with open(config_path, "r", encoding="utf-8") as f:
-                base_config = json.load(f)
-            logger.debug(f"Successfully loaded base configuration from: {config_path}")
-        except json.JSONDecodeError as e:
-            raise ValueError(f"Config Error: Failed to parse JSON in {config_path}: {e}") from e
-        except Exception as e:
-            raise ValueError(f"Config Error: Failed to read {config_path}: {e}") from e
-    else:
-        if config_path_override:
-            raise FileNotFoundError(f"Configuration Error: Specified config file not found: {config_path}")
-        else:
-            logger.warning(f"Default configuration file not found at {config_path}. Proceeding without base configuration.")
-
-    # 1. Start with base defaults
-    final_config = base_config.get("defaults", {}).copy()
-    logger.debug(f"Applied base defaults. Keys: {list(final_config.keys())}")
-
-    # 2. Merge base llm and mcpServers sections
-    if "llm" in base_config:
-        final_config.setdefault("llm", {}).update(base_config["llm"])
-        logger.debug("Merged base 'llm'.")
-    if "mcpServers" in base_config:
-        final_config.setdefault("mcpServers", {}).update(base_config["mcpServers"])
-        logger.debug("Merged base 'mcpServers'.")
-
-    # 3. Merge blueprint-specific settings
-    blueprint_settings = base_config.get("blueprints", {}).get(blueprint_class_name, {})
-    if blueprint_settings:
-        final_config.update(blueprint_settings)
-        logger.debug(f"Merged BP '{blueprint_class_name}' settings. Keys: {list(blueprint_settings.keys())}")
-
-    # 4. Determine and merge profile settings
-    # Priority: CLI > Blueprint Specific > Base Defaults > "default"
-    profile_in_bp_settings = blueprint_settings.get("default_profile")
-    profile_in_base_defaults = base_config.get("defaults", {}).get("default_profile")
-    profile_to_use = profile_override or profile_in_bp_settings or profile_in_base_defaults or "default"
-    logger.debug(f"Using profile: '{profile_to_use}'")
-    profile_settings = base_config.get("profiles", {}).get(profile_to_use, {})
-    if profile_settings:
-        final_config.update(profile_settings)
-        logger.debug(f"Merged profile '{profile_to_use}'. Keys: {list(profile_settings.keys())}")
-    elif profile_to_use != "default" and (profile_override or profile_in_bp_settings or profile_in_base_defaults):
-        logger.warning(f"Profile '{profile_to_use}' requested but not found.")
-
-    # 5. Merge CLI overrides (highest priority)
-    if cli_config_overrides:
-        final_config.update(cli_config_overrides)
-        logger.debug(f"Merged CLI overrides. Keys: {list(cli_config_overrides.keys())}")
-
-    # Ensure top-level keys exist
-    final_config.setdefault("llm", {})
-    final_config.setdefault("mcpServers", {})
-
-    # 6. Substitute environment variables in the final config
-    final_config = _substitute_env_vars(final_config)
-    logger.debug("Applied final env var substitution.")
-
-    return final_config