open-swarm 0.1.1745125888__py3-none-any.whl → 0.1.1745125904__py3-none-any.whl

{open_swarm-0.1.1745125888.dist-info → open_swarm-0.1.1745125904.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: open-swarm
-Version: 0.1.1745125888
+Version: 0.1.1745125904
 Summary: Open Swarm: Orchestrating AI Agent Swarms with Django
 Project-URL: Homepage, https://github.com/yourusername/open-swarm
 Project-URL: Documentation, https://github.com/yourusername/open-swarm/blob/main/README.md

{open_swarm-0.1.1745125888.dist-info → open_swarm-0.1.1745125904.dist-info}/RECORD

@@ -56,17 +56,17 @@ swarm/blueprints/whiskeytango_foxtrot/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCe
 swarm/blueprints/whiskeytango_foxtrot/apps.py,sha256=V1QKvyb2Vz-EtDNhhNe4tw2W9LYhNDuiaIq_fAU4ilw,334
 swarm/blueprints/whiskeytango_foxtrot/blueprint_whiskeytango_foxtrot.py,sha256=y5OUPe5-W0Bhm3nO0hBH31ucXuote3PBVgb0WeOQodE,16567
 swarm/core/agent_utils.py,sha256=exKnbJEm1VRL270x6XqQXHtJhqD8ogY3ZBIGZO_tYUE,552
-swarm/core/blueprint_base.py,sha256=tt6NUIpckafJLBr4yM7_jgdTMrtMq8wvONgNQRbmUCw,22090
-swarm/core/blueprint_discovery.py,sha256=rNbfe0D98kfWiW5MdushT8405899tfm_hnpVN5jDg_Q,5688
+swarm/core/blueprint_base.py,sha256=ZXfgCqaAVprML0KS3njHNxgldrwOCSGZrcI-fj7HyZs,40178
+swarm/core/blueprint_discovery.py,sha256=UyJuBq_u7KLQC2_I9KGioX-Bcbj2-qjhKke4ensk_Xw,5622
 swarm/core/blueprint_runner.py,sha256=TIfcIFfW86gCIeYs67ePmurKRPrcGgVYmVFGbpNuojQ,2576
 swarm/core/blueprint_utils.py,sha256=Ef_pu-RYomqzFjMg6LOSPSdbYFCbYXjEoSvK1OT49Eo,702
-swarm/core/blueprint_ux.py,sha256=9sxOCjAfXW4v1VnaTpbOw7ymCxanzXlP5qFaXTFZTK4,2853
+swarm/core/blueprint_ux.py,sha256=Lk4VFsIYyZSiDhwpLTYMaPAtDdLoVIDHaMWg9HCN7bQ,4567
 swarm/core/build_launchers.py,sha256=2NZRvX0A3jFN1mYZI5vbXkPRDoXgdUBdunruhSUogko,563
 swarm/core/build_swarm_wrapper.py,sha256=c_9oR3To4M2cZyc1uYSiysHLhUGX5FkCAQk9AG7Va2Q,231
 swarm/core/common_utils.py,sha256=jeKcN3lMdrpOYWIpErH3L5am13jHjaImpVvk2b0mps4,462
-swarm/core/config_loader.py,sha256=ldQGtv4tXeDJzL2GCylDxykZxYBo4ALFY2kS0jZ79Eo,5652
+swarm/core/config_loader.py,sha256=iSIKmB8Oc6MsI7luWZwFAIG_FNPILwnUZowKi6B1wyk,5614
 swarm/core/config_manager.py,sha256=DdrFHpTnEtZOZZdBZbL4hE3AGdaZFJQ9duaAfi7GhJw,10015
-swarm/core/output_utils.py,sha256=lEySKRDJTRGaTGUSULYgq166b4pxk3s8w5LJg5STFVo,7249
+swarm/core/output_utils.py,sha256=9rr1MNZ6Kucm78oAVAJaehlGbvgH2LY41VHzjxN1kZM,8345
 swarm/core/server_config.py,sha256=v2t7q22qZwMAPdiUZreQaLAy1706k3VbR8Wk0NCQuCQ,3224
 swarm/core/session_logger.py,sha256=92I0IGwUsRsYEISsO1HBeVWPnbBWBC4UuUzk2KstBuk,1859
 swarm/core/setup_wizard.py,sha256=yAZ7MOgc8ZGti2kjZ72G6QLFBI0lbhXAa7Wi7SeXDYo,4567
@@ -257,6 +257,7 @@ swarm/templates/rest_mode/components/top_bar.html,sha256=I-J0Bmmcr0c6_KXEEmM6mwT
 swarm/templates/websocket_partials/final_system_message.html,sha256=hZeOez70ZvYsDrmq965kFzV6wh5dBkKkP2FTiXS0FWo,128
 swarm/templates/websocket_partials/system_message.html,sha256=0eBzz9dJBmnwDwnh-X_7wDefSatbS1LepaLhXxN-qI4,171
 swarm/templates/websocket_partials/user_message.html,sha256=-TjdT4-FKFVXeYsPglG3VayDYg1A2beE5gV6AQWu-00,149
+swarm/utils/ansi_box.py,sha256=VatZxyCR83Z-taNE361vMhrm8rD-8htic5gI96V2HPg,1172
 swarm/utils/color_utils.py,sha256=utIfZ6ptGEdpHxIZiZ4gtfo5lLqZKQL5g0F8mEwMhTo,1184
 swarm/utils/context_utils.py,sha256=CsoyFALq88pcMYU8Fw1joHrssnjDuisaroEkGiDwX_8,19551
 swarm/utils/disable_tracing.py,sha256=IWe60GGs3l_pZA_OLV6qJDcAHOM2tQkMzg0Xj_x5hRE,1400
@@ -268,6 +269,8 @@ swarm/utils/message_sequence.py,sha256=7Xa7YwGPgojfkrGcl-SbeR_BWwzXGDYNqAxq8F6Xh
 swarm/utils/message_utils.py,sha256=oNTD7pfmnnu_Br24pR2VEX9afIZwFLwg2HJBLXs1blY,4074
 swarm/utils/openai_patch.py,sha256=Qogheuyh2_MTR6gO-uKgf3lu2jQc7cS72Vctc7vyXtI,1330
 swarm/utils/redact.py,sha256=vtqTztsxyBg-2qHMgAPi1lI5mJgZEb8Fqi1KKFk3bZM,2042
+swarm/ux/ansi_box.py,sha256=6mG8MpqrvDXGYU87eKqtky-ib83yt_qk2wiwf9DU5rs,1558
+swarm/ux/spinner.py,sha256=UouAin377z8sKfvgrIF8klp_bKbwsSCxd2jgelndn5Y,1613
 swarm/views/__init__.py,sha256=AcLk0R7Y69FhIVgJK2hZs8M_gCR-h_5iqUywz89yuHM,1223
 swarm/views/api_views.py,sha256=BbDEgI6Ftg-c-mMkE9DvRGZHIZ-WAZSfwqAB7j98WxM,1937
 swarm/views/chat_views.py,sha256=6UUtEJKrM2k_wi9A6AfhbbvMYunjzpY22M6hOIXASjA,15695
@@ -276,8 +279,8 @@ swarm/views/message_views.py,sha256=sDUnXyqKXC8WwIIMAlWf00s2_a2T9c75Na5FvYMJwBM,
 swarm/views/model_views.py,sha256=aAbU4AZmrOTaPeKMWtoKK7FPYHdaN3Zbx55JfKzYTRY,2937
 swarm/views/utils.py,sha256=8Usc0g0L0NPegNAyY20tJBNBy-JLwODf4VmxV0yUtpw,3627
 swarm/views/web_views.py,sha256=T1CKe-Nyv1C8aDt6QFTGWo_dkH7ojWAvS_QW9mZnZp0,7371
-open_swarm-0.1.1745125888.dist-info/METADATA,sha256=kzF5948majacP5Fn-7hO3iAr059U6MxWvH9z-eOCXpc,26977
-open_swarm-0.1.1745125888.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-open_swarm-0.1.1745125888.dist-info/entry_points.txt,sha256=fo28d0_zJrytRsh8QqkdlWQT_9lyAwYUx1WuSTDI3HM,177
-open_swarm-0.1.1745125888.dist-info/licenses/LICENSE,sha256=BU9bwRlnOt_JDIb6OT55Q4leLZx9RArDLTFnlDIrBEI,1062
-open_swarm-0.1.1745125888.dist-info/RECORD,,
+open_swarm-0.1.1745125904.dist-info/METADATA,sha256=q8jtZKzgtpfD5DLbBjdCbEdzi3jwsKfx3Nn-WwJfJV8,26977
+open_swarm-0.1.1745125904.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+open_swarm-0.1.1745125904.dist-info/entry_points.txt,sha256=fo28d0_zJrytRsh8QqkdlWQT_9lyAwYUx1WuSTDI3HM,177
+open_swarm-0.1.1745125904.dist-info/licenses/LICENSE,sha256=BU9bwRlnOt_JDIb6OT55Q4leLZx9RArDLTFnlDIrBEI,1062
+open_swarm-0.1.1745125904.dist-info/RECORD,,

swarm/core/blueprint_base.py

@@ -1,8 +1,24 @@
 # --- REMOVE noisy debug/framework prints unless SWARM_DEBUG=1 ---
 import os
+from swarm.utils.general_utils import is_debug_enabled
 
 def _should_debug():
-    return os.environ.get("SWARM_DEBUG") == "1"
+    # Standardize debug detection: SWARM_DEBUG, SWARM_LOGLEVEL, LOGLEVEL, LOG_LEVEL, DEBUG
+    import os
+    # Highest precedence: explicit SWARM_DEBUG=1 or true
+    debug_env = os.environ.get("SWARM_DEBUG")
+    if debug_env is not None:
+        return debug_env.lower() in ("1", "true", "yes", "on")
+    # Next: SWARM_LOGLEVEL or LOGLEVEL or LOG_LEVEL
+    for var in ("SWARM_LOGLEVEL", "LOGLEVEL", "LOG_LEVEL"):
+        val = os.environ.get(var)
+        if val and val.upper() == "DEBUG":
+            return True
+    # Next: DEBUG=1 or true
+    debug_std = os.environ.get("DEBUG")
+    if debug_std is not None:
+        return debug_std.lower() in ("1", "true", "yes", "on")
+    return False
 
 def _debug_print(*args, **kwargs):
     if _should_debug():
@@ -123,6 +139,16 @@ class BlueprintBase(ABC):
     console = Console()
     session_logger: 'SessionLogger' = None
 
+    def __init__(self, blueprint_id: str, config=None, config_path=None, **kwargs):
+        self.blueprint_id = blueprint_id
+        self.config_path = config_path
+        self._config = config if config is not None else None
+        self._llm_profile_name = None
+        self._llm_profile_data = None
+        self._markdown_output = None
+        self._load_configuration()  # Ensure config is loaded during init
+        # Add any additional initialization logic here
+
     def display_splash_screen(self, animated: bool = False):
         """Default splash screen. Subclasses can override for custom CLI/API branding."""
         console = Console()
@@ -133,37 +159,133 @@ class BlueprintBase(ABC):
         Loads blueprint configuration. This method is a stub for compatibility with tests that patch it.
         In production, configuration is loaded via _load_and_process_config.
         """
-        # You may override this in subclasses or patch in tests
-        return getattr(self, '_config', {})
-
-    def __init__(self, blueprint_id: str, config: dict = None, config_path: 'Optional[Path]' = None, enable_terminal_commands: 'Optional[bool]' = None, **kwargs):
+        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:
-            if not blueprint_id:
-                raise ValueError("blueprint_id cannot be empty or None")
-            self.blueprint_id = blueprint_id
-            self.config_path = config_path  # for legacy compatibility
-            self._config = config  # Allow test injection
-            self._llm_profile_name = None
-            self._llm_profile_data = None
-            self._markdown_output = None
-            # 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
+            if self._config is None:
+                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.")
+                    self._config = app_config_instance.config
+                    print("[SWARM_CONFIG_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}")
+                    # 1. CLI argument (not handled here, handled in cli_handler)
+                    # 2. Current working directory (guard against missing CWD)
+                    try:
+                        cwd_config = Path.cwd() / "swarm_config.json"
+                        print(f"[SWARM_CONFIG_DEBUG] Trying: {cwd_config}")
+                    except Exception as e:
+                        cwd_config = None
+                        if _should_debug():
+                            logger.warning(f"Unable to determine CWD for config lookup: {e}")
+                    if cwd_config and cwd_config.exists():
+                        print(f"[SWARM_CONFIG_DEBUG] Loaded: {cwd_config}")
+                        with open(cwd_config, 'r') as f:
+                            self._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"
+                        print(f"[SWARM_CONFIG_DEBUG] Trying: {xdg_config}")
+                        if xdg_config.exists():
+                            print(f"[SWARM_CONFIG_DEBUG] Loaded: {xdg_config}")
+                            with open(xdg_config, 'r') as f:
+                                self._config = json.load(f)
+                    elif (Path.home() / ".config/swarm/swarm_config.json").exists():
+                        home_config = Path.home() / ".config/swarm/swarm_config.json"
+                        print(f"[SWARM_CONFIG_DEBUG] Loaded: {home_config}")
+                        with open(home_config, 'r') as f:
+                            self._config = json.load(f)
+                    # 4. Legacy fallback: ~/.swarm/swarm_config.json
+                    elif (Path.home() / ".swarm/swarm_config.json").exists():
+                        legacy_config = Path.home() / ".swarm/swarm_config.json"
+                        print(f"[SWARM_CONFIG_DEBUG] Loaded: {legacy_config}")
+                        with open(legacy_config, 'r') as f:
+                            self._config = json.load(f)
+                    # 5. Fallback: OPENAI_API_KEY envvar
+                    elif os.environ.get("OPENAI_API_KEY"):
+                        print("[SWARM_CONFIG_DEBUG] No config file found, using OPENAI_API_KEY from env.")
+                        self._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:
+                        print("[SWARM_CONFIG_DEBUG] No config file found and OPENAI_API_KEY is not set. Using empty config.")
+                        self._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 self._config is not None:
+                    self._config = _substitute_env_vars(self._config)
+            # Ensure self._config is always a dict
+            if self._config is None:
+                self._config = {}
+            settings_section = self._config.get("settings", {})
+            llm_section = self._config.get("llm", {})
+
+            # --- 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)}")
 
-            # 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)
+            # --- Process LLM profile name and data ---
+            default_profile = settings_section.get("default_llm_profile") or "default"
+            # Only set self._llm_profile_name if explicitly provided in config
+            if "llm_profile" in self._config:
+                self._llm_profile_name = self._config["llm_profile"]
+            # Do NOT set self._llm_profile_name to default_profile here; let resolution logic handle fallback
+            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}")
 
-            self._load_and_process_config()
-        except AttributeError as e:
-            logger.debug(f"[BlueprintBase.__init__] AttributeError: {e}")
-            traceback.print_exc()
+        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
 
     def _load_and_process_config(self):
@@ -189,7 +311,7 @@ class BlueprintBase(ABC):
                     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.")
                     self._config = app_config_instance.config
-                    logger.debug("Loaded config from Django AppConfig.")
+                    print("[SWARM_CONFIG_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}")
@@ -197,28 +319,37 @@ class BlueprintBase(ABC):
                     # 2. Current working directory (guard against missing CWD)
                     try:
                         cwd_config = Path.cwd() / "swarm_config.json"
+                        print(f"[SWARM_CONFIG_DEBUG] Trying: {cwd_config}")
                     except Exception as e:
                         cwd_config = None
                         if _should_debug():
                             logger.warning(f"Unable to determine CWD for config lookup: {e}")
                     if cwd_config and cwd_config.exists():
+                        print(f"[SWARM_CONFIG_DEBUG] Loaded: {cwd_config}")
                         with open(cwd_config, 'r') as f:
                             self._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"
+                        print(f"[SWARM_CONFIG_DEBUG] Trying: {xdg_config}")
                         if xdg_config.exists():
+                            print(f"[SWARM_CONFIG_DEBUG] Loaded: {xdg_config}")
                             with open(xdg_config, 'r') as f:
                                 self._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:
+                        home_config = Path.home() / ".config/swarm/swarm_config.json"
+                        print(f"[SWARM_CONFIG_DEBUG] Loaded: {home_config}")
+                        with open(home_config, 'r') as f:
                             self._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:
+                        legacy_config = Path.home() / ".swarm/swarm_config.json"
+                        print(f"[SWARM_CONFIG_DEBUG] Loaded: {legacy_config}")
+                        with open(legacy_config, 'r') as f:
                             self._config = json.load(f)
                     # 5. Fallback: OPENAI_API_KEY envvar
                     elif os.environ.get("OPENAI_API_KEY"):
+                        print("[SWARM_CONFIG_DEBUG] No config file found, using OPENAI_API_KEY from env.")
                         self._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},
@@ -228,10 +359,11 @@ class BlueprintBase(ABC):
                         }
                         logger.info("No config file found, using default config with OPENAI_API_KEY for CLI mode.")
                     else:
+                        print("[SWARM_CONFIG_DEBUG] No config file found and OPENAI_API_KEY is not set. Using empty config.")
                         self._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 self._config is not None:
-                        self._config = _substitute_env_vars(self._config)
+                if self._config is not None:
+                    self._config = _substitute_env_vars(self._config)
             # Ensure self._config is always a dict
             if self._config is None:
                 self._config = {}
@@ -267,12 +399,14 @@ class BlueprintBase(ABC):
 
             # --- Process LLM profile name and data ---
             default_profile = settings_section.get("default_llm_profile") or "default"
-            self._llm_profile_name = self._config.get("llm_profile") or default_profile
+            # Only set self._llm_profile_name if explicitly provided in config
+            if "llm_profile" in self._config:
+                self._llm_profile_name = self._config["llm_profile"]
+            # Do NOT set self._llm_profile_name to default_profile here; let resolution logic handle fallback
             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)
@@ -285,6 +419,77 @@ class BlueprintBase(ABC):
             logger.error(f"Unexpected error loading config for blueprint '{self.blueprint_id}': {e}", exc_info=True)
             raise
 
+    def _resolve_llm_profile(self):
+        """Resolve the LLM profile for this blueprint using the following order:
+        1. If self._llm_profile_name is set, use it.
+        2. If config has 'llm_profile', use it.
+        3. If config['blueprints'][blueprint_id or stripped]['llm_profile'] is set, use it.
+        4. If settings.default_llm in self._config, use it.
+        5. If global swarm_config has blueprints.<BlueprintName>.llm_profile, use it.
+        6. If settings.default_llm in global config, use it.
+        7. If env var DEFAULT_LLM is set, use it.
+        8. Otherwise, use 'default'.
+        """
+        # Use cached value if already resolved
+        if getattr(self, '_resolved_llm_profile', None):
+            return self._resolved_llm_profile
+        name = getattr(self, 'blueprint_id', None) or getattr(self, '__class__', type(self)).__name__
+        profile = None
+        import logging
+        logger = logging.getLogger(__name__)
+        logger.debug(f"[DEBUG _resolve_llm_profile] blueprint_id/name: {name}")
+        logger.debug(f"[DEBUG _resolve_llm_profile] self._config: {self._config}")
+        # 1. Explicit override
+        if getattr(self, '_llm_profile_name', None):
+            logger.debug(f"[DEBUG _resolve_llm_profile] Using programmatic override: {self._llm_profile_name}")
+            profile = self._llm_profile_name
+        # 2. Blueprint config (top-level)
+        elif self._config and self._config.get('llm_profile'):
+            logger.debug(f"[DEBUG _resolve_llm_profile] Using top-level config llm_profile: {self._config['llm_profile']}")
+            profile = self._config['llm_profile']
+        # 3. Blueprint config (per-blueprint section)
+        elif self._config and self._config.get('blueprints'):
+            logger.debug(f"[DEBUG _resolve_llm_profile] Checking per-blueprint config for: {name}")
+            bp_cfg = self._config['blueprints'].get(name) or self._config['blueprints'].get(name.replace('Blueprint',''))
+            logger.debug(f"[DEBUG _resolve_llm_profile] bp_cfg: {bp_cfg}")
+            if isinstance(bp_cfg, dict) and 'llm_profile' in bp_cfg:
+                logger.debug(f"[DEBUG _resolve_llm_profile] Using per-blueprint llm_profile: {bp_cfg['llm_profile']}")
+                profile = bp_cfg['llm_profile']
+        # 4. settings.default_llm in self._config
+        elif self._config and self._config.get('settings') and self._config['settings'].get('default_llm'):
+            profile = self._config['settings']['default_llm']
+        # 5. Global config lookup (blueprints.<BlueprintName>.llm_profile)
+        else:
+            global_config = None
+            try:
+                import json, os
+                from pathlib import Path
+                config_paths = [Path.cwd() / 'swarm_config.json', Path.home() / '.config/swarm/swarm_config.json']
+                for path in config_paths:
+                    if path.exists():
+                        with open(path) as f:
+                            global_config = json.load(f)
+                        break
+            except Exception:
+                global_config = None
+            if global_config and 'blueprints' in global_config:
+                bp_cfg = global_config['blueprints'].get(name) or global_config['blueprints'].get(name.replace('Blueprint',''))
+                if bp_cfg and 'llm_profile' in bp_cfg:
+                    profile = bp_cfg['llm_profile']
+            # 6. settings.default_llm in global config
+            if not profile and global_config and 'settings' in global_config and global_config['settings'].get('default_llm'):
+                profile = global_config['settings']['default_llm']
+        # 7. Env var DEFAULT_LLM
+        if not profile:
+            import os
+            profile = os.environ.get('DEFAULT_LLM')
+        # 8. Otherwise, use 'default'
+        if not profile:
+            profile = 'default'
+        logger.debug(f"[DEBUG _resolve_llm_profile] Final resolved profile: {profile}")
+        self._resolved_llm_profile = profile
+        return profile
+
     @property
     def config(self) -> Dict[str, Any]:
         """Returns the loaded and processed Swarm configuration."""
@@ -299,7 +504,7 @@ class BlueprintBase(ABC):
         Raises a clear error if provider is missing.
         """
         llm_section = self._config.get("llm", {}) if self._config else {}
-        profile_name = self.llm_profile_name or "default"
+        profile_name = self._resolve_llm_profile()
         profile = llm_section.get(profile_name)
         if not profile:
             raise ValueError(f"LLM profile '{profile_name}' not found in config: {llm_section}")
@@ -310,9 +515,13 @@ class BlueprintBase(ABC):
     @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
+        return self._resolve_llm_profile()
+
+    @llm_profile_name.setter
+    def llm_profile_name(self, value: str):
+        self._llm_profile_name = value
+        if hasattr(self, '_resolved_llm_profile'):
+            del self._resolved_llm_profile
 
     @property
     def slash_commands(self):
@@ -341,6 +550,22 @@ class BlueprintBase(ABC):
             return bool(settings["default_markdown_output"])
         return False
 
+    @property
+    def splash(self) -> str:
+        """
+        Plain text splash/description for API, docs, etc.
+        """
+        title = self.metadata.get('title', 'Blueprint')
+        desc = self.metadata.get('description', '')
+        return f"{title}: {desc}"
+
+    def get_cli_splash(self, color='cyan', emoji='🤖') -> str:
+        """
+        CLI splash with ANSI/emoji, only for terminal output.
+        """
+        from swarm.utils.ansi_box import ansi_box
+        return ansi_box(self.splash, color=color, emoji=emoji)
+
     def _get_model_instance(self, profile_name: str):
         """Retrieves or creates an LLM Model instance, respecting LITELLM_MODEL/DEFAULT_LLM if set."""
         if not hasattr(self, '_model_instance_cache'):
@@ -374,7 +599,7 @@ class BlueprintBase(ABC):
             from agents.models.openai_responses import OpenAIResponsesModel
             model_instance = OpenAIResponsesModel(model=model_name, openai_client=client)
         else:
-            from agents.models.openai_completions import OpenAIChatCompletionsModel
+            from agents.models.openai_chatcompletions import OpenAIChatCompletionsModel
             model_instance = OpenAIChatCompletionsModel(model=model_name, openai_client=client)
         self._model_instance_cache[profile_name] = model_instance
         return model_instance
@@ -382,7 +607,7 @@ class BlueprintBase(ABC):
     def make_agent(self, name, instructions, tools, mcp_servers=None, **kwargs):
         """Factory for creating an Agent with the correct model instance from framework config."""
         from agents import Agent  # Ensure Agent is always in scope
-        model_instance = self._get_model_instance(self.config.get("llm_profile", "default"))
+        model_instance = self._get_model_instance(self._resolve_llm_profile())
         return Agent(
             name=name,
             model=model_instance,
@@ -446,6 +671,26 @@ class BlueprintBase(ABC):
             self.session_logger.close()
             self.session_logger = None
 
+    def print_help(self):
+        """
+        Print CLI usage/help for this blueprint. Subclasses can override for custom help.
+        """
+        blueprint_name = getattr(self, 'blueprint_id', self.__class__.__name__)
+        print(f"\nUsage: {blueprint_name} [options] <prompt>\n")
+        print("Options:")
+        print("  -m, --model <model>         Model to use for completions")
+        print("  -q, --quiet                 Non-interactive mode (only prints final output)")
+        print("  -o, --output <file>         Output file")
+        print("  --project-doc <file>        Include a markdown file as context")
+        print("  --full-context              Load all project files as context")
+        print("  --approval <policy>         Set approval policy for agent actions (suggest, auto-edit, full-auto)")
+        print("  --version                   Show version and exit")
+        print("  -h, --help                  Show this help message and exit\n")
+        print("Examples:")
+        print(f"  {blueprint_name} \"Refactor all utils into a single module.\"")
+        print(f"  {blueprint_name} --full-context \"Summarize all TODOs in the project.\"")
+        print(f"  {blueprint_name} --approval full-auto \"Upgrade all dependencies and update the changelog.\"")
+
     @abstractmethod
     async def run(self, messages: List[Dict[str, Any]], **kwargs: Any) -> AsyncGenerator[Dict[str, Any], None]:
         """
@@ -457,3 +702,68 @@ class BlueprintBase(ABC):
         pprint.pprint(dict(os.environ))
         raise NotImplementedError("Subclasses must implement the 'run' method.")
         yield {}
+
+    def _load_configuration(self):
+        """
+        Loads blueprint configuration. This method is a stub for compatibility with tests that patch it.
+        In production, configuration is loaded via _load_and_process_config.
+        """
+        import os
+        import json
+        from pathlib import Path
+        import traceback
+        try:
+            if self._config is None:
+                try:
+                    if self.config_path is not None:
+                        self.config_path = Path(self.config_path)
+                        if self.config_path.exists():
+                            if is_debug_enabled():
+                                print(f"[DEBUG LOADER] Reading config from {self.config_path}")
+                            raw = self.config_path.read_text()
+                            if is_debug_enabled():
+                                print(f"[DEBUG LOADER] Raw config contents:\n{raw}")
+                            self._config = json.loads(raw)
+                            assert isinstance(self._config, dict), f"Config not a dict: {type(self._config)}"
+                            assert self._config, "Config loaded but is empty!"
+                        else:
+                            logger.warning(f"Config path {self.config_path} does not exist. Using empty config.")
+                            self._config = {}
+                    else:
+                        # Try cwd, then default, then /mnt/models/open-swarm-mcp/swarm_config.json
+                        cwd_path = Path(os.getcwd()) / "swarm_config.json"
+                        if cwd_path.exists():
+                            if is_debug_enabled():
+                                print(f"[DEBUG LOADER] Reading config from {cwd_path}")
+                            raw = cwd_path.read_text()
+                            if is_debug_enabled():
+                                print(f"[DEBUG LOADER] Raw config contents:\n{raw}")
+                            self._config = json.loads(raw)
+                            assert isinstance(self._config, dict), f"Config not a dict: {type(self._config)}"
+                            assert self._config, "Config loaded but is empty!"
+                        else:
+                            # Fallback to /mnt/models/open-swarm-mcp/swarm_config.json
+                            mnt_path = Path("/mnt/models/open-swarm-mcp/swarm_config.json")
+                            if mnt_path.exists():
+                                if is_debug_enabled():
+                                    print(f"[DEBUG LOADER] Reading config from {mnt_path}")
+                                raw = mnt_path.read_text()
+                                if is_debug_enabled():
+                                    print(f"[DEBUG LOADER] Raw config contents:\n{raw}")
+                                self._config = json.loads(raw)
+                                assert isinstance(self._config, dict), f"Config not a dict: {type(self._config)}"
+                                assert self._config, "Config loaded but is empty!"
+                            else:
+                                self._config = {}
+                except Exception as e:
+                    print(f"[FATAL CONFIG LOAD ERROR] {e}")
+                    traceback.print_exc()
+                    self._config = {}
+            # Ensure self._config is always a dict
+            if self._config is None:
+                self._config = {}
+            return self._config
+
+        except Exception as e:
+            logger.error(f"Unexpected error loading config for blueprint '{self.blueprint_id}': {e}", exc_info=True)
+            raise

swarm/core/blueprint_discovery.py

@@ -17,10 +17,7 @@ try:
 except ImportError:
     # This logger call is now safe
     logger.error("Failed to import BlueprintBase from swarm.core.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
+    # REMOVED DUMMY BlueprintBase to prevent MRO/import bugs. Always import BlueprintBase from swarm.core.blueprint_base
 
 
 class BlueprintLoadError(Exception):

swarm/core/blueprint_ux.py

@@ -15,11 +15,11 @@ class BlueprintUX:
         box += "┗"+"━"*20
         return box
 
-# Integrate unique improvements from the feature branch
 import time
 import itertools
 
 # Style presets
+
 def get_style(style):
     if style == "serious":
         return {
@@ -56,7 +56,9 @@ class BlueprintUXImproved:
         return spinner_states[state_idx % len(spinner_states)]
 
     def summary(self, op_type, result_count, params):
-        return f"{op_type} | Results: {result_count} | Params: {params}"
+        # Enhanced: pretty param formatting
+        param_str = ', '.join(f'{k}={v!r}' for k, v in (params or {}).items()) if params else 'None'
+        return f"{op_type} | Results: {result_count} | Params: {param_str}"
 
     def progress(self, current, total=None):
         if total:
@@ -70,4 +72,38 @@ class BlueprintUXImproved:
             header = "[Semantic Search Results]"
         else:
             header = "[Results]"
-        return f"{header}\n" + "\n".join(results)
+        # Enhanced: visually distinct divider
+        divider = "\n" + ("=" * 40) + "\n"
+        return f"{header}{divider}" + "\n".join(results)
+
+    def ansi_emoji_box(self, title, content, summary=None, params=None, result_count=None, op_type=None, style=None, color=None, status=None):
+        """
+        Unified ANSI/emoji box for search/analysis/fileops results.
+        Summarizes: operation, result count, params, and allows for periodic updates.
+        Supports color and status for advanced UX.
+        """
+        style_conf = get_style(style or self.style)
+        # Color/status logic
+        color_map = {
+            "success": "92",  # green
+            "info": "94",     # blue
+            "warning": "93",  # yellow
+            "error": "91",    # red
+            None: "94",         # default blue
+        }
+        ansi_color = color_map.get(status, color_map[None])
+        box = f"\033[{ansi_color}m" + style_conf["border_top"] + "\033[0m\n"
+        box += f"\033[{ansi_color}m{style_conf['border_side']} {style_conf['emoji']} {title}"
+        if op_type:
+            box += f" | {op_type}"
+        if result_count is not None:
+            box += f" | Results: {result_count}"
+        box += "\033[0m\n"
+        if params:
+            box += f"\033[{ansi_color}m{style_conf['border_side']} Params: {params}\033[0m\n"
+        if summary:
+            box += f"\033[{ansi_color}m{style_conf['border_side']} {summary}\033[0m\n"
+        for line in content.split('\n'):
+            box += f"\033[{ansi_color}m{style_conf['border_side']} {line}\033[0m\n"
+        box += f"\033[{ansi_color}m" + style_conf["border_bottom"] + "\033[0m"
+        return box

swarm/core/config_loader.py

@@ -9,15 +9,15 @@ 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."""
+    import os
     if isinstance(value, str):
+        # Always expand env vars in any string
         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
+    return value
 
 def load_environment(project_root: Path):
     """Loads environment variables from a `.env` file located at the project root."""

swarm/core/output_utils.py

@@ -7,6 +7,7 @@ import logging
 import os
 import sys
 from typing import List, Dict, Any
+import re
 
 # Optional import for markdown rendering
 try:
@@ -106,7 +107,26 @@ def pretty_print_response(messages: List[Dict[str, Any]], use_markdown: bool = F
             if msg_content:
                 # --- DEBUG PRINT ---
                 print(f"\n[DEBUG Assistant content found, printing/rendering... Rich={RICH_AVAILABLE}, Markdown={use_markdown}]", flush=True)
-                if use_markdown and RICH_AVAILABLE:
+                # --- CODE FENCE HIGHLIGHTING ---
+                if RICH_AVAILABLE and '```' in msg_content:
+                    import re
+                    code_fence_pattern = r"```([\w\d]*)\n([\s\S]*?)```"
+                    matches = re.findall(code_fence_pattern, msg_content)
+                    if matches:
+                        from rich.syntax import Syntax
+                        from rich.console import Console
+                        console = Console()
+                        for lang, code in matches:
+                            syntax = Syntax(code, lang or "python", theme="monokai", line_numbers=False)
+                            console.print(syntax)
+                        # Optionally print any non-code parts
+                        non_code = re.split(code_fence_pattern, msg_content)
+                        for i, part in enumerate(non_code):
+                            if i % 3 == 0 and part.strip():
+                                print(part.strip(), flush=True)
+                    else:
+                        print(msg_content, flush=True)
+                elif use_markdown and RICH_AVAILABLE:
                     render_markdown(msg_content)
                 else:
                     print(msg_content, flush=True)

swarm/utils/ansi_box.py

@@ -0,0 +1,34 @@
+import shutil
+
+ANSI_COLORS = {
+    'cyan': '\033[96m',
+    'green': '\033[92m',
+    'yellow': '\033[93m',
+    'magenta': '\033[95m',
+    'blue': '\033[94m',
+    'red': '\033[91m',
+    'white': '\033[97m',
+    'grey': '\033[90m',
+    'reset': '\033[0m',
+}
+
+
+def ansi_box(text, color='cyan', emoji='🤖', width=None):
+    """
+    Draw a fancy ANSI box around the given text, with color and emoji.
+    """
+    lines = [line.rstrip() for line in text.strip('\n').split('\n')]
+    max_len = max(len(line) for line in lines)
+    if width is None:
+        try:
+            width = min(shutil.get_terminal_size((80, 20)).columns, max_len + 6)
+        except Exception:
+            width = max_len + 6
+    box_width = max(width, max_len + 6)
+    color_code = ANSI_COLORS.get(color, ANSI_COLORS['cyan'])
+    reset = ANSI_COLORS['reset']
+    top = f"{color_code}╔{'═' * (box_width-2)}╗{reset}"
+    title = f"{color_code}║ {emoji} {' ' * (box_width-6)}║{reset}"
+    content = [f"{color_code}║ {line.ljust(box_width-4)} ║{reset}" for line in lines]
+    bottom = f"{color_code}╚{'═' * (box_width-2)}╝{reset}"
+    return '\n'.join([top, title] + content + [bottom])

swarm/ux/ansi_box.py

@@ -0,0 +1,43 @@
+import sys
+
+def ansi_box(title, content, count=None, params=None, style='default', emoji=None):
+    """
+    Print a visually distinct ANSI box summarizing search/analysis results.
+    - title: e.g. 'Searched filesystem', 'Analyzed code'
+    - content: main result string or list of strings
+    - count: result count (optional)
+    - params: dict of search parameters (optional)
+    - style: 'default', 'success', 'warning', etc.
+    - emoji: optional emoji prefix
+    """
+    border = {
+        'default': '━',
+        'success': '━',
+        'warning': '━',
+    }.get(style, '━')
+    color = {
+        'default': '\033[36m',  # Cyan
+        'success': '\033[32m',  # Green
+        'warning': '\033[33m',  # Yellow
+    }.get(style, '\033[36m')
+    reset = '\033[0m'
+    box_width = 80
+    lines = []
+    head = f"{emoji + ' ' if emoji else ''}{title}"
+    if count is not None:
+        head += f" | Results: {count}"
+    if params:
+        head += f" | Params: {params}"
+    lines.append(color + border * box_width + reset)
+    lines.append(color + f"{head[:box_width]:^{box_width}}" + reset)
+    lines.append(color + border * box_width + reset)
+    if isinstance(content, str):
+        content = [content]
+    for line in content:
+        for l in str(line).split('\n'):
+            lines.append(f"{l[:box_width]:<{box_width}}")
+    lines.append(color + border * box_width + reset)
+    print("\n".join(lines))
+
+# Example usage:
+# ansi_box('Searched filesystem', 'Found 12 files', count=12, params={'pattern': '*.py'}, style='success', emoji='💾')

swarm/ux/spinner.py

@@ -0,0 +1,53 @@
+import sys
+import threading
+import time
+
+class Spinner:
+    """
+    Displays spinner states: Generating., Generating.., Generating..., Running...,
+    and switches to 'Taking longer than expected' after a timeout.
+    """
+    def __init__(self, base_message="Generating", long_wait_timeout=8):
+        self.base_message = base_message
+        self.states = [".", "..", "...", "..", "."]
+        self.running = False
+        self.thread = None
+        self.long_wait_timeout = long_wait_timeout
+        self._long_wait = False
+
+    def start(self):
+        self.running = True
+        self.thread = threading.Thread(target=self._spin, daemon=True)
+        self.thread.start()
+
+    def stop(self):
+        self.running = False
+        if self.thread:
+            self.thread.join()
+        sys.stdout.write("\r" + " " * 80 + "\r")
+        sys.stdout.flush()
+
+    def _spin(self):
+        idx = 0
+        start_time = time.time()
+        while self.running:
+            if not self._long_wait and (time.time() - start_time > self.long_wait_timeout):
+                self._long_wait = True
+            if self._long_wait:
+                msg = f"{self.base_message}... Taking longer than expected"
+            else:
+                msg = f"{self.base_message}{self.states[idx % len(self.states)]}"
+            sys.stdout.write(f"\r{msg}")
+            sys.stdout.flush()
+            time.sleep(0.4)
+            idx += 1
+
+    def set_message(self, message):
+        self.base_message = message
+        self._long_wait = False
+
+# Example usage:
+# spinner = Spinner()
+# spinner.start()
+# ... do work ...
+# spinner.stop()