open-swarm 0.1.1748636259__py3-none-any.whl → 0.1.1748636455__py3-none-any.whl

swarm/extensions/blueprint/output_utils.py

@@ -19,77 +19,64 @@ logger = logging.getLogger(__name__)
 
 def render_markdown(content: str) -> None:
     """Render markdown content using rich, if available."""
-    # --- DEBUG PRINT ---
-    print(f"\n[DEBUG render_markdown called with rich={RICH_AVAILABLE}]", flush=True)
     if not RICH_AVAILABLE:
-        print(content, flush=True) # Fallback print with flush
+        print(content)
         return
     console = Console()
     md = Markdown(content)
-    console.print(md) # Rich handles flushing
+    console.print(md)
 
 def pretty_print_response(messages: List[Dict[str, Any]], use_markdown: bool = False, spinner=None) -> None:
     """Format and print messages, optionally rendering assistant content as markdown."""
-    # --- DEBUG PRINT ---
-    print(f"\n[DEBUG pretty_print_response called with {len(messages)} messages, use_markdown={use_markdown}]", flush=True)
-
     if spinner:
         spinner.stop()
-        sys.stdout.write("\r\033[K") # Clear spinner line
+        sys.stdout.write("\r\033[K")
         sys.stdout.flush()
 
     if not messages:
         logger.debug("No messages to print in pretty_print_response.")
         return
 
-    for i, msg in enumerate(messages):
-         # --- DEBUG PRINT ---
-        print(f"\n[DEBUG Processing message {i}: type={type(msg)}]", flush=True)
+    for msg in messages:
         if not isinstance(msg, dict):
-            print(f"[DEBUG Skipping non-dict message {i}]", flush=True)
             continue
 
         role = msg.get("role")
         sender = msg.get("sender", role if role else "Unknown")
         msg_content = msg.get("content")
         tool_calls = msg.get("tool_calls")
-        # --- DEBUG PRINT ---
-        print(f"[DEBUG Message {i}: role={role}, sender={sender}, has_content={bool(msg_content)}, has_tools={bool(tool_calls)}]", flush=True)
-
 
         if role == "assistant":
-            print(f"\033[94m{sender}\033[0m: ", end="", flush=True)
+            print(f"\033[94m{sender}\033[0m: ", end="")
             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:
                     render_markdown(msg_content)
                 else:
-                    # --- DEBUG PRINT ---
-                    print(f"\n[DEBUG Using standard print for content:]", flush=True)
-                    print(msg_content, flush=True) # Added flush
+                    print(msg_content)
             elif not tool_calls:
-                print(flush=True) # Flush newline if no content/tools
+                print()
 
             if tool_calls and isinstance(tool_calls, list):
-                print("  \033[92mTool Calls:\033[0m", flush=True)
+                print("  \033[92mTool Calls:\033[0m")
                 for tc in tool_calls:
-                    if not isinstance(tc, dict): continue
+                    if not isinstance(tc, dict):
+                        continue
                     func = tc.get("function", {})
                     tool_name = func.get("name", "Unnamed Tool")
                     args_str = func.get("arguments", "{}")
-                    try: args_obj = json.loads(args_str); args_pretty = ", ".join(f"{k}={v!r}" for k, v in args_obj.items())
-                    except json.JSONDecodeError: args_pretty = args_str
-                    print(f"    \033[95m{tool_name}\033[0m({args_pretty})", flush=True)
+                    try:
+                        args_obj = json.loads(args_str)
+                        args_pretty = ", ".join(f"{k}={v!r}" for k, v in args_obj.items())
+                    except json.JSONDecodeError:
+                        args_pretty = args_str
+                    print(f"    \033[95m{tool_name}\033[0m({args_pretty})")
 
         elif role == "tool":
             tool_name = msg.get("tool_name", msg.get("name", "tool"))
             tool_id = msg.get("tool_call_id", "N/A")
-            try: content_obj = json.loads(msg_content); pretty_content = json.dumps(content_obj, indent=2)
-            except (json.JSONDecodeError, TypeError): pretty_content = msg_content
-            print(f"  \033[93m[{tool_name} Result ID: {tool_id}]\033[0m:\n    {pretty_content.replace(chr(10), chr(10) + '    ')}", flush=True)
-        else:
-            # --- DEBUG PRINT ---
-            print(f"[DEBUG Skipping message {i} with role '{role}']", flush=True)
-
-
+            try:
+                content_obj = json.loads(msg_content)
+                pretty_content = json.dumps(content_obj, indent=2)
+            except (json.JSONDecodeError, TypeError):
+                pretty_content = msg_content
+            print(f"  \033[93m[{tool_name} Result ID: {tool_id}]\033[0m:\n    {pretty_content.replace(chr(10), chr(10) + '    ')}")

swarm/extensions/config/config_loader.py

@@ -9,27 +9,19 @@ import logging
 from typing import Any, Dict, List, Tuple, Optional
 from pathlib import Path
 from dotenv import load_dotenv
+# Import save_server_config carefully
 try: from .server_config import save_server_config
 except ImportError: save_server_config = None
-
-SWARM_DEBUG = os.getenv("SWARM_DEBUG", "False").lower() in ("true", "1", "yes")
-try: from swarm.settings import BASE_DIR
-except ImportError: BASE_DIR = Path(__file__).resolve().parent.parent.parent
-
+from swarm.settings import DEBUG, BASE_DIR
 from swarm.utils.redact import redact_sensitive_data
 
 logger = logging.getLogger(__name__)
-logger.setLevel(logging.DEBUG if SWARM_DEBUG else logging.INFO)
-
-# Add handler only if needed, DO NOT set handler level conditionally here
-if not logger.handlers and not logging.getLogger().hasHandlers():
+logger.setLevel(logging.DEBUG if DEBUG else logging.INFO)
+if not logger.handlers:
     stream_handler = logging.StreamHandler()
     formatter = logging.Formatter("[%(levelname)s] %(asctime)s - %(name)s:%(lineno)d - %(message)s")
     stream_handler.setFormatter(formatter)
     logger.addHandler(stream_handler)
-    # --- REMOVED CONDITIONAL HANDLER LEVEL SETTING ---
-    # if not SWARM_DEBUG:
-    #     stream_handler.setLevel(logging.WARNING)
 
 config: Dict[str, Any] = {}
 load_dotenv()
@@ -40,54 +32,68 @@ def process_config(config_dict: dict) -> dict:
     try:
         resolved_config = resolve_placeholders(config_dict)
         if logger.isEnabledFor(logging.DEBUG): logger.debug("Config after resolving placeholders: " + json.dumps(redact_sensitive_data(resolved_config), indent=2))
+
         disable_merge = os.getenv("DISABLE_MCP_MERGE", "false").lower() in ("true", "1", "yes")
         if not disable_merge:
             if os.name == "nt": external_mcp_path = Path(os.getenv("APPDATA", Path.home())) / "Claude" / "claude_desktop_config.json"
             else: external_mcp_path = Path.home() / ".vscode-server" / "data" / "User" / "globalStorage" / "rooveterinaryinc.roo-cline" / "settings" / "cline_mcp_settings.json"
+
             if external_mcp_path.exists():
                 logger.info(f"Found external MCP settings file at: {external_mcp_path}")
                 try:
-                    with open(external_mcp_path, "r", encoding='utf-8') as mcp_file: external_mcp_config = json.load(mcp_file)
+                    with open(external_mcp_path, "r") as mcp_file: external_mcp_config = json.load(mcp_file)
                     if logger.isEnabledFor(logging.DEBUG): logger.debug("Loaded external MCP settings: " + json.dumps(redact_sensitive_data(external_mcp_config), indent=2))
-                    main_mcp_servers = resolved_config.get("mcpServers", {}); external_mcp_servers = external_mcp_config.get("mcpServers", {})
-                    merged_mcp_servers = main_mcp_servers.copy(); servers_added_count = 0
-                    for name, server_cfg in external_mcp_servers.items():
-                        if name not in merged_mcp_servers and not server_cfg.get("disabled", False): merged_mcp_servers[name] = server_cfg; servers_added_count += 1
-                    if servers_added_count > 0: resolved_config["mcpServers"] = merged_mcp_servers; logger.info(f"Merged {servers_added_count} MCP servers.");
+
+                    main_mcp_servers = resolved_config.get("mcpServers", {})
+                    external_mcp_servers = external_mcp_config.get("mcpServers", {})
+                    merged_mcp_servers = main_mcp_servers.copy()
+                    servers_added_count = 0
+                    for server_name, server_config in external_mcp_servers.items():
+                        if server_name not in merged_mcp_servers and not server_config.get("disabled", False):
+                            merged_mcp_servers[server_name] = server_config
+                            servers_added_count += 1
+                    if servers_added_count > 0:
+                         resolved_config["mcpServers"] = merged_mcp_servers
+                         logger.info(f"Merged {servers_added_count} MCP servers from external settings.")
+                         if logger.isEnabledFor(logging.DEBUG): logger.debug("Merged MCP servers config: " + json.dumps(redact_sensitive_data(merged_mcp_servers), indent=2))
                     else: logger.debug("No new MCP servers added from external settings.")
                 except Exception as merge_err: logger.error(f"Failed to load/merge MCP settings from '{external_mcp_path}': {merge_err}", exc_info=logger.isEnabledFor(logging.DEBUG))
             else: logger.debug(f"External MCP settings file not found at {external_mcp_path}. Skipping merge.")
-        else: logger.debug("MCP settings merge disabled.")
-    except Exception as e: logger.error(f"Failed during config processing: {e}", exc_info=logger.isEnabledFor(logging.DEBUG)); raise
+        else: logger.debug("MCP settings merge disabled via DISABLE_MCP_MERGE env var.")
+    except Exception as e: logger.error(f"Failed during configuration processing: {e}", exc_info=logger.isEnabledFor(logging.DEBUG)); raise
     globals()["config"] = resolved_config
     return resolved_config
 
 def resolve_placeholders(obj: Any) -> Any:
-    """Recursively resolve ${VAR_NAME} placeholders."""
+    """Recursively resolve ${VAR_NAME} placeholders. Returns None if var not found."""
     if isinstance(obj, dict): return {k: resolve_placeholders(v) for k, v in obj.items()}
     elif isinstance(obj, list): return [resolve_placeholders(item) for item in obj]
     elif isinstance(obj, str):
-        pattern = re.compile(r'\$\{(\w+(?:[_-]\w+)*)\}')
-        resolved_string = obj; any_unresolved = False
-        for var_name in pattern.findall(obj):
-            env_value = os.getenv(var_name); placeholder = f'${{{var_name}}}'
+        pattern = re.compile(r'\$\{(\w+)\}')
+        resolved_string = obj
+        placeholders_found = pattern.findall(obj)
+        all_resolved = True # Flag to track if all placeholders in string were resolved
+        for var_name in placeholders_found:
+            env_value = os.getenv(var_name)
+            placeholder = f'${{{var_name}}}'
             if env_value is None:
-                log_level = logging.DEBUG
+                logger.warning(f"Env var '{var_name}' not set for placeholder '{placeholder}'. Placeholder will resolve to None.")
+                # If only a placeholder exists, return None directly
                 if resolved_string == placeholder:
-                     log_level = logging.WARNING
-                     resolved_string = None
-                     any_unresolved = True
-                     logger.log(log_level, f"Env var '{var_name}' not set for placeholder '{placeholder}'. Resolving to None.")
                      return None
-                else:
-                    resolved_string = resolved_string.replace(placeholder, "")
-                    any_unresolved = True
-                    logger.log(log_level, f"Env var '{var_name}' not set for placeholder '{placeholder}'. Removing from string.")
+                # If placeholder is part of larger string, replace with empty string or marker?
+                # Let's replace with empty string for now to avoid partial resolution issues.
+                resolved_string = resolved_string.replace(placeholder, "")
+                all_resolved = False # Mark that not all placeholders resolved fully
             else:
-                 resolved_string = resolved_string.replace(placeholder, env_value)
-                 if logger.isEnabledFor(logging.DEBUG): logger.debug(f"Resolved placeholder '{placeholder}' using env var '{var_name}'.")
-        if any_unresolved and resolved_string is not None:
-             logger.debug(f"String '{obj}' contained unresolved placeholders. Result: '{resolved_string}'")
+                resolved_string = resolved_string.replace(placeholder, env_value)
+                if logger.isEnabledFor(logging.DEBUG): logger.debug(f"Resolved placeholder '{placeholder}' using env var '{var_name}'.")
+
+        # If any placeholder failed to resolve in a mixed string, log it.
+        # If the original string was *only* an unresolved placeholder, we already returned None.
+        if not all_resolved and len(placeholders_found) > 0:
+            logger.warning(f"String '{obj}' contained unresolved placeholders. Result: '{resolved_string}'")
+
         return resolved_string
     else: return obj
 
@@ -97,86 +103,238 @@ def load_server_config(file_path: Optional[str] = None) -> dict:
     if file_path:
          path_obj = Path(file_path)
          if path_obj.is_file(): config_path = path_obj; logger.info(f"Using provided config file path: {config_path}")
-         else: logger.warning(f"Provided path '{file_path}' not found. Searching standard locations.")
+         else: logger.warning(f"Provided path '{file_path}' not found/not file. Searching standard locations.")
     if not config_path:
-        standard_paths = [ Path.cwd() / "swarm_config.json", Path(BASE_DIR) / "swarm_config.json", Path.home() / ".swarm" / "swarm_config.json" ]
-        config_path = next((p for p in standard_paths if p.is_file()), None)
-        if not config_path: raise FileNotFoundError(f"Config file 'swarm_config.json' not found. Checked: {[str(p) for p in standard_paths]}")
-        logger.info(f"Using config file found at: {config_path}")
+        current_dir = Path.cwd()
+        standard_paths = [ current_dir / "swarm_config.json", Path(BASE_DIR) / "swarm_config.json", Path.home() / ".swarm" / "swarm_config.json" ]
+        for candidate in standard_paths:
+            if candidate.is_file(): config_path = candidate; logger.info(f"Using config file found at: {config_path}"); break
+        if not config_path: raise FileNotFoundError(f"Config file 'swarm_config.json' not found in provided path or standard locations: {[str(p) for p in standard_paths]}")
+    logger.debug(f"Attempting to load config from: {config_path}")
     try:
+        # Ensure reading with UTF-8 encoding
         raw_config = json.loads(config_path.read_text(encoding='utf-8'))
         if logger.isEnabledFor(logging.DEBUG): logger.debug(f"Raw config loaded: {redact_sensitive_data(raw_config)}")
-        processed_config = process_config(raw_config)
-        globals()["config"] = processed_config
-        logger.info(f"Config loaded and processed from {config_path}")
-        return processed_config
-    except json.JSONDecodeError as e: logger.critical(f"Invalid JSON in {config_path}: {e}"); raise ValueError(f"Invalid JSON") from e
-    except Exception as e: logger.critical(f"Failed to read/process config {config_path}: {e}"); raise ValueError("Failed to load/process config") from e
+    except json.JSONDecodeError as json_err:
+        logger.critical(f"Invalid JSON in config file {config_path}: {json_err}")
+        raise ValueError(f"Invalid JSON in config {config_path}: {json_err}") from json_err
+    except Exception as load_err:
+        logger.critical(f"Failed to read config file {config_path}: {load_err}")
+        raise ValueError(f"Failed to read config {config_path}") from load_err
+    try:
+         processed_config = process_config(raw_config)
+         globals()["config"] = processed_config
+         logger.info(f"Config loaded and processed from {config_path}")
+         return processed_config
+    except Exception as process_err: logger.critical(f"Failed to process config from {config_path}: {process_err}", exc_info=True); raise ValueError(f"Failed to process config from {config_path}") from process_err
+
+# --- Start of Missing Functions ---
+
+def are_required_mcp_servers_configured(required_servers: List[str], config_dict: Dict[str, Any]) -> Tuple[bool, List[str]]:
+    """Checks if required MCP servers are present in the config."""
+    if not required_servers: return True, []
+    mcp_servers = config_dict.get("mcpServers", {})
+    if not isinstance(mcp_servers, dict):
+        logger.warning("MCP servers configuration ('mcpServers') is missing or invalid.")
+        return False, required_servers # All are missing if section is invalid
+
+    missing = [server for server in required_servers if server not in mcp_servers]
+    if missing:
+        logger.warning(f"Required MCP servers are missing from configuration: {missing}")
+        return False, missing
+    else:
+        logger.debug("All required MCP servers are configured.")
+        return True, []
+
+def validate_mcp_server_env(mcp_servers: Dict[str, Any], required_servers: Optional[List[str]] = None) -> None:
+    """
+    Validates that required environment variables specified within MCP server
+    configurations are actually set in the environment. Assumes placeholders in
+    the config's `env` section values are *already resolved* before calling this.
+
+    Args:
+        mcp_servers: Dictionary of MCP server configurations (placeholders resolved).
+        required_servers: Optional list of specific server names to validate. If None, validates all.
+
+    Raises:
+        ValueError: If a required environment variable for a validated server is not set.
+    """
+    servers_to_validate = mcp_servers
+    if required_servers is not None:
+        servers_to_validate = {k: v for k, v in mcp_servers.items() if k in required_servers}
+        missing_keys = [k for k in required_servers if k not in mcp_servers]
+        if missing_keys: logger.warning(f"Required MCP servers missing during env validation: {missing_keys}")
+
+    logger.debug(f"Validating environment variables for MCP servers: {list(servers_to_validate.keys())}")
+
+    for server_name, server_config in servers_to_validate.items():
+        env_section = server_config.get("env", {})
+        if not isinstance(env_section, dict): logger.warning(f"'env' for MCP server '{server_name}' invalid. Skipping."); continue
+        logger.debug(f"Validating env for MCP server '{server_name}'.")
+        for env_key, env_spec in env_section.items():
+            # Determine if required (default is True)
+            is_required = env_spec.get("required", True) if isinstance(env_spec, dict) else True
+            if not is_required: logger.debug(f"Skipping optional env var '{env_key}' for '{server_name}'."); continue
+
+            # Get the RESOLVED value from the config dict
+            config_value = env_spec.get("value") if isinstance(env_spec, dict) else env_spec
+
+            # Check if the resolved value is missing or empty
+            if config_value is None or (isinstance(config_value, str) and not config_value.strip()):
+                # This check assumes resolve_placeholders returned None or empty for missing env vars
+                 raise ValueError(f"Required env var '{env_key}' for MCP server '{server_name}' is missing or empty in resolved config.")
+            else: logger.debug(f"Env var '{env_key}' for '{server_name}' present in resolved config.")
+
+def get_default_llm_config(config_dict: Dict[str, Any]) -> Dict[str, Any]:
+    """Retrieves the config dict for the default LLM profile."""
+    selected_llm_name = os.getenv("DEFAULT_LLM", "default")
+    logger.debug(f"Getting default LLM config for profile: '{selected_llm_name}'")
+    llm_profiles = config_dict.get("llm", {})
+    if not isinstance(llm_profiles, dict): raise ValueError("'llm' section missing or invalid.")
+    llm_config = llm_profiles.get(selected_llm_name)
+    if not llm_config:
+        if selected_llm_name != "default" and "default" in llm_profiles:
+             logger.warning(f"Profile '{selected_llm_name}' not found, falling back to 'default'.")
+             llm_config = llm_profiles.get("default")
+             if not llm_config: # Guard against empty 'default'
+                  raise ValueError(f"LLM profile '{selected_llm_name}' not found and 'default' profile is missing or invalid.")
+        else: raise ValueError(f"LLM profile '{selected_llm_name}' (nor 'default') not found.")
+    if not isinstance(llm_config, dict): raise ValueError(f"LLM profile '{selected_llm_name}' invalid.")
+    if logger.isEnabledFor(logging.DEBUG): logger.debug(f"Using LLM profile '{selected_llm_name}': {redact_sensitive_data(llm_config)}")
+    return llm_config
+
+def validate_api_keys(config_dict: Dict[str, Any], selected_llm: str = "default") -> Dict[str, Any]:
+    """Validates API key presence for a selected LLM profile (called by load_llm_config)."""
+    logger.debug(f"Validating API keys for LLM profile '{selected_llm}'.")
+    llm_profiles = config_dict.get("llm", {})
+    if not isinstance(llm_profiles, dict): logger.warning("No 'llm' section found, skipping API key validation."); return config_dict
+    llm_config = llm_profiles.get(selected_llm)
+    if not isinstance(llm_config, dict): logger.warning(f"No config for LLM profile '{selected_llm}', skipping validation."); return config_dict
+
+    api_key_required = llm_config.get("api_key_required", True)
+    api_key = llm_config.get("api_key")
+    # Use the fact that resolve_placeholders now returns None for missing env vars
+    key_is_missing_or_empty = api_key is None or (isinstance(api_key, str) and not api_key.strip())
+
+    if api_key_required and key_is_missing_or_empty:
+         # If the key is missing/empty *after* resolving placeholders, it means
+         # neither the config nor the specific env var had it.
+         # Check OPENAI_API_KEY as a general fallback ONLY IF not found specifically.
+         common_fallback_var = "OPENAI_API_KEY"
+         fallback_key = os.getenv(common_fallback_var)
+
+         specific_env_var_name = f"{selected_llm.upper()}_API_KEY" # e.g., OPENAI_API_KEY, ANTHROPIC_API_KEY
+
+         # Check specific env var first
+         specific_key = os.getenv(specific_env_var_name)
+         if specific_key:
+             logger.info(f"API key missing/empty in resolved config for '{selected_llm}', using env var '{specific_env_var_name}'.")
+             # Update the config dict in place (or return a modified copy if preferred)
+             llm_config["api_key"] = specific_key
+         elif fallback_key:
+             logger.info(f"API key missing/empty for '{selected_llm}' and specific env var '{specific_env_var_name}' not set. Using fallback env var '{common_fallback_var}'.")
+             llm_config["api_key"] = fallback_key
+         else:
+             raise ValueError(f"Required API key for LLM profile '{selected_llm}' is missing or empty. Checked config, env var '{specific_env_var_name}', and fallback '{common_fallback_var}'.")
+
+    elif api_key_required: logger.debug(f"API key validation successful for '{selected_llm}'.")
+    else: logger.debug(f"API key not required for '{selected_llm}'.")
+    # Return the potentially modified config_dict (or just llm_config part if preferred)
+    return config_dict
+
+
+def validate_and_select_llm_provider(config_dict: Dict[str, Any]) -> Dict[str, Any]:
+    """Validates the selected LLM provider and returns its config."""
+    logger.debug("Validating and selecting LLM provider based on DEFAULT_LLM.")
+    try:
+        llm_name = os.getenv("DEFAULT_LLM", "default")
+        llm_config = load_llm_config(config_dict, llm_name) # Use load_llm_config which includes validation
+        logger.debug(f"LLM provider '{llm_name}' validated successfully.")
+        return llm_config
+    except ValueError as e: logger.error(f"LLM provider validation failed: {e}"); raise
+
+def inject_env_vars(config_dict: Dict[str, Any]) -> Dict[str, Any]:
+    """Ensures placeholders are resolved (delegates to resolve_placeholders)."""
+    logger.debug("Ensuring environment variable placeholders are resolved.")
+    return resolve_placeholders(config_dict)
 
 def load_llm_config(config_dict: Optional[Dict[str, Any]] = None, llm_name: Optional[str] = None) -> Dict[str, Any]:
-    """Loads, validates, and resolves API keys for a specific LLM profile."""
+    """Loads and validates config for a specific LLM profile."""
     if config_dict is None:
+        # Try loading from global if not provided
         global_config = globals().get("config")
         if not global_config:
              try: config_dict = load_server_config(); globals()["config"] = config_dict
              except Exception as e: raise ValueError("Global config not loaded and no config_dict provided.") from e
-        else: config_dict = global_config
+        else:
+             config_dict = global_config
 
     target_llm_name = llm_name or os.getenv("DEFAULT_LLM", "default")
-    logger.debug(f"LOAD_LLM: Loading profile: '{target_llm_name}'.")
-
+    logger.debug(f"Loading LLM config for profile: '{target_llm_name}'")
+    # Resolve placeholders FIRST using the provided or loaded config_dict
     resolved_config = resolve_placeholders(config_dict)
+
     llm_profiles = resolved_config.get("llm", {})
     if not isinstance(llm_profiles, dict): raise ValueError("'llm' section must be a dictionary.")
-
     llm_config = llm_profiles.get(target_llm_name)
-    config_source = f"config file ('{target_llm_name}')"
-    logger.debug(f"LOAD_LLM: Initial lookup for '{target_llm_name}': {'Found' if llm_config else 'Missing'}")
 
+    # Fallback Logic (if profile not found after resolving)
     if not llm_config:
-        logger.warning(f"LOAD_LLM: Config for '{target_llm_name}' not found. Generating fallback.")
-        config_source = "fallback generation"
+        logger.warning(f"LLM config for '{target_llm_name}' not found. Generating fallback.")
         fb_provider = os.getenv("DEFAULT_LLM_PROVIDER", "openai"); fb_model = os.getenv("DEFAULT_LLM_MODEL", "gpt-4o")
-        llm_config = { "provider": fb_provider, "model": fb_model, "api_key": None, "base_url": None }
-        logger.debug(f"LOAD_LLM: Generated fallback core config: {llm_config}")
+        # Check env vars for fallback API key *after* trying the specific one based on target_llm_name
+        specific_env_key = os.getenv(f"{target_llm_name.upper()}_API_KEY")
+        openai_env_key = os.getenv("OPENAI_API_KEY")
+        fb_api_key = specific_env_key or openai_env_key or "" # Use specific, then openai, then empty
+
+        specific_env_url = os.getenv(f"{target_llm_name.upper()}_BASE_URL")
+        openai_env_url = os.getenv("OPENAI_API_BASE")
+        default_openai_url = "https://api.openai.com/v1" if fb_provider == "openai" else None
+        fb_base_url = specific_env_url or openai_env_url or default_openai_url
+
+        llm_config = {k: v for k, v in {
+             "provider": fb_provider,
+             "model": fb_model,
+             "base_url": fb_base_url,
+             "api_key": fb_api_key, # Use the determined fallback key
+             # Determine requirement based on provider (adjust providers as needed)
+             "api_key_required": fb_provider not in ["ollama", "lmstudio", "groq"] # Example: groq might need key
+             }.items() if v is not None}
+        logger.debug(f"Using fallback config for '{target_llm_name}': {redact_sensitive_data(llm_config)}")
 
     if not isinstance(llm_config, dict): raise ValueError(f"LLM profile '{target_llm_name}' must be a dictionary.")
 
-    final_api_key = llm_config.get("api_key"); key_log_source = f"{config_source} (resolved)" if final_api_key else config_source
-    provider = llm_config.get("provider"); api_key_required = llm_config.get("api_key_required", True)
-    logger.debug(f"LOAD_LLM: Initial key from {key_log_source}: {'****' if final_api_key else 'None'}. Required={api_key_required}")
-
-    logger.debug(f"LOAD_LLM: Checking ENV vars for potential override.")
-    specific_env_var_name = f"{provider.upper()}_API_KEY" if provider else "PROVIDER_API_KEY"
-    common_fallback_var = "OPENAI_API_KEY"
-    specific_key_from_env = os.getenv(specific_env_var_name); fallback_key_from_env = os.getenv(common_fallback_var)
-    logger.debug(f"LOAD_LLM: Env Check: Specific ('{specific_env_var_name}')={'****' if specific_key_from_env else 'None'}, Fallback ('{common_fallback_var}')={'****' if fallback_key_from_env else 'None'}")
-
-    if specific_key_from_env:
-        if final_api_key != specific_key_from_env: logger.info(f"LOAD_LLM: Overriding key with env var '{specific_env_var_name}'.")
-        final_api_key = specific_key_from_env; key_log_source = f"env var '{specific_env_var_name}'"
-    elif fallback_key_from_env:
-        if not specific_key_from_env or specific_env_var_name == common_fallback_var:
-            if final_api_key != fallback_key_from_env: logger.info(f"LOAD_LLM: Overriding key with fallback env var '{common_fallback_var}'.")
-            final_api_key = fallback_key_from_env; key_log_source = f"env var '{common_fallback_var}'"
-        else: logger.debug(f"LOAD_LLM: Specific env key '{specific_env_var_name}' unset, NOT using fallback.")
-    else: logger.debug(f"LOAD_LLM: No relevant API key found in environment variables.")
-
-    key_is_still_missing_or_empty = final_api_key is None or (isinstance(final_api_key, str) and not final_api_key.strip())
-    logger.debug(f"LOAD_LLM: Key after env check: {'****' if final_api_key else 'None'}. Source: {key_log_source}. Still MissingOrEmpty={key_is_still_missing_or_empty}")
-
-    if key_is_still_missing_or_empty:
-        if api_key_required and not os.getenv("SUPPRESS_DUMMY_KEY"):
-             final_api_key = "sk-DUMMYKEY"; key_log_source = "dummy key"; logger.warning(f"LOAD_LLM: Applying dummy key for '{target_llm_name}'.")
-        elif api_key_required:
-             key_log_source = "MISSING - ERROR"; raise ValueError(f"Required API key for LLM profile '{target_llm_name}' is missing.")
-        else: key_log_source = "Not Required/Not Found"
-
-    final_llm_config = llm_config.copy(); final_llm_config["api_key"] = final_api_key; final_llm_config["_log_key_source"] = key_log_source
-    logger.debug(f"LOAD_LLM: Returning final config for '{target_llm_name}': {redact_sensitive_data(final_llm_config)}")
-    return final_llm_config
+    # --- API Key Validation integrated here ---
+    api_key_required = llm_config.get("api_key_required", True)
+    # Check the api_key *within the potentially generated or loaded llm_config*
+    api_key = llm_config.get("api_key")
+    key_is_missing_or_empty = api_key is None or (isinstance(api_key, str) and not api_key.strip())
+
+    if api_key_required and key_is_missing_or_empty:
+         # Key is missing/empty after config resolution and fallback generation.
+         # Re-check environment variables as a final step before erroring.
+         specific_env_var_name = f"{target_llm_name.upper()}_API_KEY"
+         common_fallback_var = "OPENAI_API_KEY"
+         specific_key_from_env = os.getenv(specific_env_var_name)
+         fallback_key_from_env = os.getenv(common_fallback_var)
+
+         if specific_key_from_env:
+              logger.info(f"API key missing/empty in config/fallback for '{target_llm_name}', using env var '{specific_env_var_name}'.")
+              llm_config["api_key"] = specific_key_from_env # Update config with key from env
+         elif fallback_key_from_env:
+              logger.info(f"API key missing/empty for '{target_llm_name}' and specific env var '{specific_env_var_name}' not set. Using fallback env var '{common_fallback_var}'.")
+              llm_config["api_key"] = fallback_key_from_env # Update config with key from env
+         else:
+              # If still missing after checking env vars again, raise error
+              raise ValueError(f"Required API key for LLM profile '{target_llm_name}' is missing or empty. Checked config, fallback generation, env var '{specific_env_var_name}', and fallback '{common_fallback_var}'.")
+
+    # Log final config being used
+    if logger.isEnabledFor(logging.DEBUG): logger.debug(f"Final loaded config for '{target_llm_name}': {redact_sensitive_data(llm_config)}")
+    return llm_config
+
 
 def get_llm_model(config_dict: Dict[str, Any], llm_name: Optional[str] = None) -> str:
+    """Retrieves the 'model' name string for a specific LLM profile."""
     target_llm_name = llm_name or os.getenv("DEFAULT_LLM", "default")
     try: llm_config = load_llm_config(config_dict, target_llm_name)
     except ValueError as e: raise ValueError(f"Could not load config for LLM '{target_llm_name}': {e}") from e
@@ -186,23 +344,9 @@ def get_llm_model(config_dict: Dict[str, Any], llm_name: Optional[str] = None) -
     return model_name
 
 def load_and_validate_llm(config_dict: Dict[str, Any], llm_name: Optional[str] = None) -> Dict[str, Any]:
+    """Loads and validates config for a specific LLM (wrapper for load_llm_config)."""
     target_llm_name = llm_name or os.getenv("DEFAULT_LLM", "default")
     logger.debug(f"Loading and validating LLM (via load_llm_config) for profile: {target_llm_name}")
     return load_llm_config(config_dict, target_llm_name)
 
-def get_server_params(server_config: Dict[str, Any], server_name: str) -> Optional[Dict[str, Any]]:
-    """Extracts and validates parameters needed to start an MCP server."""
-    command = server_config.get("command"); args = server_config.get("args", []); config_env = server_config.get("env", {})
-    if not command: logger.error(f"MCP server '{server_name}' missing 'command'."); return None
-    if not isinstance(args, list): logger.error(f"MCP server '{server_name}' 'args' must be list."); return None
-    if not isinstance(config_env, dict): logger.error(f"MCP server '{server_name}' 'env' must be dict."); return None
-    env = {**os.environ.copy(), **config_env}; valid_env = {}
-    for k, v in env.items():
-        if v is None: logger.warning(f"Env var '{k}' for MCP server '{server_name}' resolved to None. Omitting.")
-        else: valid_env[k] = str(v)
-    return {"command": command, "args": args, "env": valid_env}
-
-def list_mcp_servers(config_dict: Dict[str, Any]) -> List[str]:
-     """Returns a list of configured MCP server names."""
-     return list(config_dict.get("mcpServers", {}).keys())
-
+# --- End of Missing Functions ---

swarm/extensions/mcp/__init__.py

@@ -0,0 +1 @@
+# This is the __init__.py for the 'mcp' package.

swarm/extensions/mcp/cache_utils.py

@@ -0,0 +1,32 @@
+# cache_utils.py
+
+from typing import Any
+
+class DummyCache:
+    """A dummy cache that performs no operations."""
+    def get(self, key: str, default: Any = None) -> Any:
+        return default
+
+    def set(self, key: str, value: Any, timeout: int = None) -> None:
+        pass
+
+def get_cache():
+    """
+    Attempts to retrieve Django's cache. If Django isn't available or configured,
+    returns a DummyCache instance.
+    """
+    try:
+        import django
+        from django.conf import settings
+        from django.core.cache import cache as django_cache
+        from django.core.exceptions import ImproperlyConfigured
+
+        if not settings.configured:
+            # Django settings are not configured; return DummyCache
+            return DummyCache()
+        
+        return django_cache
+
+    except (ImportError, ImproperlyConfigured):
+        # Django is not installed or not properly configured; use DummyCache
+        return DummyCache()