open-swarm 0.1.1743070217__py3-none-any.whl

swarm/extensions/blueprint/blueprint_discovery.py

@@ -0,0 +1,112 @@
+"""
+Blueprint Discovery Module for Open Swarm MCP.
+
+This module dynamically discovers and imports blueprints from specified directories.
+It identifies classes derived from BlueprintBase as valid blueprints and extracts their metadata.
+"""
+
+import importlib.util
+import inspect
+import logging
+import os
+from pathlib import Path
+from typing import Dict, List, Any
+from swarm.settings import DEBUG
+
+logger = logging.getLogger(__name__)
+logger.setLevel(logging.DEBUG if DEBUG else logging.INFO)
+
+try:
+    from .blueprint_base import BlueprintBase
+except ImportError as e:
+    logger.critical(f"Failed to import BlueprintBase: {e}")
+    raise
+
+def discover_blueprints(directories: List[str]) -> Dict[str, Dict[str, Any]]:
+    """
+    Discover and load blueprints from specified directories.
+    Extract metadata including title, description, and other attributes.
+
+    Args:
+        directories (List[str]): List of directories to search for blueprints.
+
+    Returns:
+        Dict[str, Dict[str, Any]]: Dictionary containing blueprint metadata.
+    """
+    blueprints = {}
+    logger.info("Starting blueprint discovery.")
+    swarm_blueprints = os.getenv("SWARM_BLUEPRINTS", "").split(",")
+    if swarm_blueprints and swarm_blueprints[0]:
+        logger.debug(f"Filtering blueprints to: {swarm_blueprints}")
+
+    for directory in directories:
+        logger.debug(f"Searching for blueprints in: {directory}")
+        dir_path = Path(directory)
+
+        if not dir_path.exists() or not dir_path.is_dir():
+            logger.warning(f"Invalid directory: {directory}. Skipping...")
+            continue
+
+        for blueprint_file in dir_path.rglob("blueprint_*.py"):
+            module_name = blueprint_file.stem
+            blueprint_name = module_name.replace("blueprint_", "")
+            if swarm_blueprints and swarm_blueprints[0] and blueprint_name not in swarm_blueprints:
+                logger.debug(f"Skipping blueprint '{blueprint_name}' not in SWARM_BLUEPRINTS")
+                continue
+            module_path = str(blueprint_file.parent)
+
+            logger.debug(f"Found blueprint file: {blueprint_file}")
+            logger.debug(f"Module name: {module_name}, Blueprint name: {blueprint_name}, Module path: {module_path}")
+
+            try:
+                spec = importlib.util.spec_from_file_location(module_name, str(blueprint_file))
+                if spec is None or spec.loader is None:
+                    logger.error(f"Cannot load module spec for blueprint file: {blueprint_file}. Skipping.")
+                    continue
+                module = importlib.util.module_from_spec(spec)
+                spec.loader.exec_module(module)
+                logger.debug(f"Successfully imported module: {module_name}")
+
+                for name, obj in inspect.getmembers(module, inspect.isclass):
+                    if not issubclass(obj, BlueprintBase) or obj is BlueprintBase:
+                        continue
+
+                    logger.debug(f"Discovered blueprint class: {name}")
+
+                    try:
+                        metadata = obj.metadata
+                        if callable(metadata):
+                            metadata = metadata()
+                        elif isinstance(metadata, property):
+                            if metadata.fget is not None:
+                                metadata = metadata.fget(obj)
+                            else:
+                                logger.error(f"Blueprint '{blueprint_name}' property 'metadata' has no getter.")
+                                raise ValueError(f"Blueprint '{blueprint_name}' metadata is inaccessible.")
+
+                        if not isinstance(metadata, dict):
+                            logger.error(f"Metadata for blueprint '{blueprint_name}' is not a dictionary.")
+                            raise ValueError(f"Metadata for blueprint '{blueprint_name}' is invalid or inaccessible.")
+
+                        if "title" not in metadata or "description" not in metadata:
+                            logger.error(f"Required metadata fields (title, description) are missing for blueprint '{blueprint_name}'.")
+                            raise ValueError(f"Metadata for blueprint '{blueprint_name}' is invalid or inaccessible.")
+
+                    except Exception as e:
+                        logger.error(f"Error retrieving metadata for blueprint '{blueprint_name}': {e}")
+                        continue
+
+                    blueprints[blueprint_name] = {
+                        "blueprint_class": obj,
+                        "title": metadata["title"],
+                        "description": metadata["description"],
+                    }
+                    logger.debug(f"Added blueprint '{blueprint_name}' with metadata: {metadata}")
+            except ImportError as e:
+                logger.error(f"Failed to import module '{module_name}': {e}")
+            except Exception as e:
+                logger.error(f"Unexpected error importing '{module_name}': {e}", exc_info=True)
+
+    logger.info("Blueprint discovery complete.")
+    logger.debug(f"Discovered blueprints: {list(blueprints.keys())}")
+    return blueprints

swarm/extensions/blueprint/blueprint_utils.py

@@ -0,0 +1,17 @@
+"""
+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

@@ -0,0 +1,12 @@
+"""
+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/django_utils.py

@@ -0,0 +1,203 @@
+"""
+Django integration utilities for blueprint extensions.
+"""
+
+import logging
+import os
+import importlib.util
+from typing import Any, TYPE_CHECKING
+from django.conf import settings # Import settings directly
+# Import necessary URL handling functions
+from django.urls import clear_url_caches, get_resolver, get_urlconf, set_urlconf, URLPattern, URLResolver
+from collections import OrderedDict
+from django.apps import apps as django_apps
+
+# Use TYPE_CHECKING to avoid circular import issues if BlueprintBase imports this indirectly
+if TYPE_CHECKING:
+    from .blueprint_base import BlueprintBase
+
+logger = logging.getLogger(__name__)
+
+def register_django_components(blueprint: 'BlueprintBase') -> None:
+    """Register Django settings and URLs if applicable for the given blueprint."""
+    if blueprint.skip_django_registration or getattr(blueprint, "_urls_registered", False):
+        logger.debug(f"Skipping Django registration for {blueprint.__class__.__name__}: Skipped by flag or already registered.")
+        return
+    if not os.environ.get("DJANGO_SETTINGS_MODULE"):
+        logger.debug("Skipping Django registration: DJANGO_SETTINGS_MODULE not set.")
+        return
+
+    try:
+        # App readiness check less critical now if called within test fixtures after setup
+        if not django_apps.ready and not getattr(settings, 'TESTING', False):
+            logger.debug("Django apps not ready; registration likely handled by AppConfig.ready().")
+            return
+
+        _load_local_settings(blueprint)
+        _merge_installed_apps(blueprint) # Still attempt, might need restart/reload
+
+        if hasattr(blueprint, 'register_blueprint_urls') and callable(blueprint.register_blueprint_urls):
+             logger.debug(f"Calling blueprint-specific register_blueprint_urls for {blueprint.__class__.__name__}")
+             blueprint.register_blueprint_urls()
+             blueprint._urls_registered = True
+        else:
+             logger.debug(f"Using generic URL registration for {blueprint.__class__.__name__}")
+             _register_blueprint_urls_generic(blueprint)
+
+    except ImportError:
+        logger.warning("Django not available; skipping Django component registration.")
+    except Exception as e:
+        logger.error(f"Failed to register Django components for {blueprint.__class__.__name__}: {e}", exc_info=True)
+
+def _load_local_settings(blueprint: 'BlueprintBase') -> None:
+    """Load local settings.py from the blueprint's directory if it exists."""
+    try:
+        module_spec = importlib.util.find_spec(blueprint.__class__.__module__)
+        if module_spec and module_spec.origin:
+            blueprint_dir = os.path.dirname(module_spec.origin)
+            local_settings_path = os.path.join(blueprint_dir, "settings.py")
+            if os.path.isfile(local_settings_path):
+                spec = importlib.util.spec_from_file_location(f"{blueprint.__class__.__module__}.local_settings", local_settings_path)
+                if spec and spec.loader:
+                    local_settings = importlib.util.module_from_spec(spec)
+                    blueprint.local_settings = local_settings
+                    spec.loader.exec_module(local_settings)
+                    logger.debug(f"Loaded local settings from {local_settings_path} for {blueprint.__class__.__name__}")
+                else:
+                    logger.warning(f"Could not create module spec for local settings at {local_settings_path}")
+                    blueprint.local_settings = None
+            else: blueprint.local_settings = None
+        else: blueprint.local_settings = None
+    except Exception as e:
+        logger.error(f"Error loading local settings for {blueprint.__class__.__name__}: {e}", exc_info=True)
+        blueprint.local_settings = None
+
+
+def _merge_installed_apps(blueprint: 'BlueprintBase') -> None:
+    """Merge INSTALLED_APPS from blueprint's local settings into main Django settings."""
+    if hasattr(blueprint, "local_settings") and blueprint.local_settings and hasattr(blueprint.local_settings, "INSTALLED_APPS"):
+        try:
+            blueprint_apps = getattr(blueprint.local_settings, "INSTALLED_APPS", [])
+            if not isinstance(blueprint_apps, (list, tuple)):
+                 logger.warning(f"Blueprint {blueprint.__class__.__name__}'s local INSTALLED_APPS is not a list or tuple.")
+                 return
+
+            apps_added = False
+            if isinstance(settings.INSTALLED_APPS, tuple):
+                settings.INSTALLED_APPS = list(settings.INSTALLED_APPS)
+
+            for app in blueprint_apps:
+                if app not in settings.INSTALLED_APPS:
+                    settings.INSTALLED_APPS.append(app)
+                    apps_added = True
+                    logger.debug(f"Added app '{app}' from blueprint {blueprint.__class__.__name__} to INSTALLED_APPS.")
+
+            if apps_added:
+                 logger.info(f"Merged INSTALLED_APPS from blueprint {blueprint.__class__.__name__}. App registry reload might be needed.")
+                 # Attempt app registry reload - Use with caution!
+                 try:
+                     logger.debug("Attempting to reload Django app registry...")
+                     django_apps.app_configs = OrderedDict()
+                     django_apps.ready = False
+                     django_apps.clear_cache()
+                     django_apps.populate(settings.INSTALLED_APPS)
+                     logger.info("Successfully reloaded Django app registry.")
+                 except RuntimeError as e:
+                      logger.error(f"Could not reload app registry (likely reentrant call): {e}")
+                 except Exception as e:
+                      logger.error(f"Error reloading Django app registry: {e}", exc_info=True)
+
+
+        except ImportError:
+             logger.error("Could not import django.conf.settings to merge INSTALLED_APPS.")
+        except Exception as e:
+            logger.error(f"Error merging INSTALLED_APPS for {blueprint.__class__.__name__}: {e}", exc_info=True)
+
+def _register_blueprint_urls_generic(blueprint: 'BlueprintBase') -> None:
+    """Generic function to register blueprint URLs based on metadata."""
+    if getattr(blueprint, "_urls_registered", False):
+        logger.debug(f"URLs for {blueprint.__class__.__name__} already registered.")
+        return
+
+    module_path = blueprint.metadata.get("django_modules", {}).get("urls")
+    url_prefix = blueprint.metadata.get("url_prefix", "")
+
+    if not module_path:
+        logger.debug(f"No 'urls' module specified in metadata for {blueprint.__class__.__name__}; skipping generic URL registration.")
+        return
+
+    try:
+        from django.urls import include, path
+        from importlib import import_module
+
+        root_urlconf_name = settings.ROOT_URLCONF
+        if not root_urlconf_name:
+             logger.error("settings.ROOT_URLCONF is not set.")
+             return
+
+        # --- Get the root urlpatterns list directly ---
+        # This is potentially fragile if ROOT_URLCONF itself changes, but necessary for tests
+        try:
+             root_urlconf_module = import_module(root_urlconf_name)
+             if not hasattr(root_urlconf_module, 'urlpatterns') or not isinstance(root_urlconf_module.urlpatterns, list):
+                  logger.error(f"Cannot modify urlpatterns in '{root_urlconf_name}'. It's missing or not a list.")
+                  return
+             root_urlpatterns = root_urlconf_module.urlpatterns
+        except ImportError:
+             logger.error(f"Could not import main URLconf '{root_urlconf_name}' to modify urlpatterns.")
+             return
+
+        # Import the blueprint's URL module
+        try:
+            urls_module = import_module(module_path)
+            if not hasattr(urls_module, "urlpatterns"):
+                logger.debug(f"Blueprint URL module '{module_path}' has no 'urlpatterns'.")
+                blueprint._urls_registered = True
+                return
+        except ImportError:
+            logger.error(f"Could not import blueprint URL module: '{module_path}'")
+            return
+
+        if url_prefix and not url_prefix.endswith('/'): url_prefix += '/'
+        app_name = blueprint.metadata.get("cli_name", blueprint.__class__.__name__.lower())
+        new_pattern = path(url_prefix, include((urls_module, app_name)))
+
+        # Check if an identical pattern already exists
+        already_exists = False
+        for existing_pattern in root_urlpatterns:
+             # Compare based on pattern regex and included module/app_name if possible
+             if (isinstance(existing_pattern, (URLPattern, URLResolver)) and
+                 str(existing_pattern.pattern) == str(new_pattern.pattern) and
+                 getattr(existing_pattern, 'app_name', None) == app_name and
+                 getattr(existing_pattern, 'namespace', None) == getattr(new_pattern, 'namespace', None)): # Check namespace too
+                  # A bit more robust check, might need refinement
+                  logger.warning(f"URL pattern for prefix '{url_prefix}' and app '{app_name}' seems already registered. Skipping.")
+                  already_exists = True
+                  break
+
+        if not already_exists:
+            root_urlpatterns.append(new_pattern)
+            logger.info(f"Dynamically registered URLs from '{module_path}' at prefix '{url_prefix}' (app_name: '{app_name}')")
+
+            # --- Force update of URL resolver ---
+            clear_url_caches()
+            # Reload the root URLconf module itself
+            try:
+                reload(root_urlconf_module)
+                logger.debug(f"Reloaded root URLconf module: {root_urlconf_name}")
+            except Exception as e:
+                 logger.error(f"Failed to reload root URLconf module: {e}")
+            # Try setting urlconf to None to force re-reading from settings
+            set_urlconf(None)
+            # Explicitly getting the resolver again might help
+            resolver = get_resolver(get_urlconf())
+            resolver._populate() # Re-populate cache
+            logger.info(f"Cleared URL caches and attempted to refresh resolver for {root_urlconf_name}.")
+
+        blueprint._urls_registered = True
+
+    except ImportError as e:
+        logger.error(f"Import error during URL registration for {blueprint.__class__.__name__}: {e}")
+    except Exception as e:
+        logger.error(f"Unexpected error registering URLs for {blueprint.__class__.__name__}: {e}", exc_info=True)
+

swarm/extensions/blueprint/interactive_mode.py

@@ -0,0 +1,102 @@
+"""
+Interactive mode logic for blueprint extensions.
+"""
+
+import logging
+from typing import List, Dict, Any # Added Any
+
+# Import the standalone output function
+from .output_utils import pretty_print_response
+
+logger = logging.getLogger(__name__)
+
+def run_interactive_mode(blueprint, stream: bool = False) -> None:
+    """
+    Run the interactive mode for a blueprint instance.
+
+    This function implements the interactive loop where the user is
+prompted for input,
+    and responses are generated and printed using the blueprint inst
+ance's methods.
+    """
+    logger.debug("Starting interactive mode.")
+    if not blueprint.starting_agent or not blueprint.swarm:
+        logger.error("Starting agent or Swarm not initialized.")
+        # --- FIX: Terminate string literal correctly ---
+        raise ValueError("Starting agent and Swarm must be initialized.")
+        # --- End FIX ---
+
+    print("Blueprint Interactive Mode 🐝")
+    messages: List[Dict[str, Any]] = []
+    first_input = True
+    message_count = 0
+    while True:
+        spinner = getattr(blueprint, 'spinner', None)
+        if spinner: spinner.stop()
+
+        try:
+             user_input = input(blueprint.prompt).strip()
+        except (EOFError, KeyboardInterrupt):
+             print("\nExiting interactive mode.")
+             break
+
+        if user_input.lower() in {"exit", "quit", "/quit"}:
+            print("Exiting interactive mode.")
+            break
+        if first_input:
+            blueprint.context_variables["user_goal"] = user_input
+            first_input = False
+        messages.append({"role": "user", "content": user_input})
+        message_count += 1
+
+        try:
+             result = blueprint.run_with_context(messages, blueprint.context_variables)
+             swarm_response = result.get("response")
+             blueprint.context_variables = result.get("context_variables", blueprint.context_variables)
+
+             response_messages_objects = []
+             if hasattr(swarm_response, 'messages'):
+                 response_messages_objects = swarm_response.messages
+             elif isinstance(swarm_response, dict) and 'messages' in swarm_response:
+                  raw_msgs = swarm_response.get('messages', [])
+                  if raw_msgs and not isinstance(raw_msgs[0], dict):
+                       try: response_messages_objects = raw_msgs
+                       except Exception: logger.error("Failed to process messages from dict response."); response_messages_objects = []
+                  else: response_messages_objects = raw_msgs
+
+             response_messages_dicts = []
+             if response_messages_objects:
+                 try:
+                     response_messages_dicts = [
+                         msg.model_dump(exclude_none=True) if hasattr(msg, 'model_dump') else msg
+                         for msg in response_messages_objects
+                     ]
+                 except Exception as e:
+                      logger.error(f"Failed to dump response messages to dict: {e}")
+                      response_messages_dicts = [{"role": "system", "content": "[Error displaying response]"}]
+
+             if stream:
+                 logger.warning("Streaming not fully supported in this interactive mode version.")
+                 pretty_print_response(messages=response_messages_dicts, use_markdown=getattr(blueprint, 'use_markdown', False), spinner=spinner)
+             else:
+                 pretty_print_response(messages=response_messages_dicts, use_markdown=getattr(blueprint, 'use_markdown', False), spinner=spinner)
+
+             messages.extend(response_messages_dicts)
+
+             if getattr(blueprint, 'update_user_goal', False) and \
+                (message_count - getattr(blueprint, 'last_goal_update_count', 0)) >= \
+                getattr(blueprint, 'update_user_goal_frequency', 5):
+                 try:
+                     import asyncio
+                     asyncio.run(blueprint._update_user_goal_async(messages))
+                     blueprint.last_goal_update_count = message_count
+                 except AttributeError: logger.warning("Blueprint missing '_update_user_goal_async'.")
+                 except Exception as e: logger.error(f"Error updating goal: {e}", exc_info=True)
+
+             if getattr(blueprint, 'auto_complete_task', False):
+                  logger.warning("Auto-complete task not implemented in this interactive loop version.")
+
+        except Exception as e:
+             logger.error(f"Error during interactive loop turn: {e}", exc_info=True)
+             print(f"\n[An error occurred: {e}]")
+

swarm/extensions/blueprint/modes/rest_mode.py

@@ -0,0 +1,37 @@
+import logging
+import subprocess
+import sys
+import os
+from swarm.utils.color_utils import color_text
+
+logger = logging.getLogger(__name__)
+
+def run_rest_mode(agent):
+    """
+    Launches the Django development server to serve REST endpoints.
+
+    Args:
+        agent: The agent object passed in by main.py, not actually used here.
+    """
+    try:
+        logger.info("Launching Django server for REST mode...")
+        
+        # Retrieve host and port from environment variables, defaulting to 0.0.0.0:8000
+        host = os.getenv("HOST", "0.0.0.0")
+        port = os.getenv("PORT", "8000")
+        
+        logger.info(f"Using host '{host}' and port '{port}' for the Django server.")
+        print(color_text(f"Starting Django REST server on http://{host}:{port}", "cyan"))
+
+        # Use subprocess to run the Django server with the specified host and port
+        subprocess.run(
+            [sys.executable, "manage.py", "runserver", f"{host}:{port}"],
+            check=True
+        )
+
+    except subprocess.CalledProcessError as e:
+        logger.error(f"Failed to launch Django server: {e}")
+        print(color_text(f"Failed to launch Django server: {e}", "red"))
+    except Exception as e:
+        logger.error(f"Unexpected error in run_rest_mode: {e}", exc_info=True)
+        print(color_text(f"Unexpected error in run_rest_mode: {e}", "red"))

swarm/extensions/blueprint/output_utils.py

@@ -0,0 +1,95 @@
+"""
+Output utilities for Swarm blueprints.
+"""
+
+import json
+import logging
+import sys
+from typing import List, Dict, Any
+
+# Optional import for markdown rendering
+try:
+    from rich.markdown import Markdown
+    from rich.console import Console
+    RICH_AVAILABLE = True
+except ImportError:
+    RICH_AVAILABLE = False
+
+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
+        return
+    console = Console()
+    md = Markdown(content)
+    console.print(md) # Rich handles flushing
+
+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.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)
+        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)
+            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
+            elif not tool_calls:
+                print(flush=True) # Flush newline if no content/tools
+
+            if tool_calls and isinstance(tool_calls, list):
+                print("  \033[92mTool Calls:\033[0m", flush=True)
+                for tc in tool_calls:
+                    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)
+
+        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)
+
+

swarm/extensions/blueprint/spinner.py

@@ -0,0 +1,91 @@
+"""
+Simple terminal spinner for interactive feedback during long operations.
+"""
+
+import os
+import sys
+import threading
+import time
+
+class Spinner:
+    """Simple terminal spinner for interactive feedback."""
+    # Define spinner characters (can be customized)
+    SPINNER_CHARS = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏']
+    # SPINNER_CHARS = ['|', '/', '-', '\\'] # Simpler alternative
+
+    def __init__(self, interactive: bool):
+        """
+        Initialize the spinner.
+
+        Args:
+            interactive (bool): Hint whether the environment is interactive.
+                                Spinner is disabled if False or if output is not a TTY.
+        """
+        self.interactive = interactive
+        # Check if output is a TTY (terminal) and interactive flag is True
+        self.is_tty = sys.stdout.isatty()
+        self.enabled = self.interactive and self.is_tty
+        self.running = False
+        self.thread: Optional[threading.Thread] = None
+        self.status = ""
+        self.index = 0
+
+    def start(self, status: str = "Processing..."):
+        """Start the spinner with an optional status message."""
+        if not self.enabled or self.running:
+            return # Do nothing if disabled or already running
+        self.status = status
+        self.running = True
+        # Run the spinner animation in a separate daemon thread
+        self.thread = threading.Thread(target=self._spin, daemon=True)
+        self.thread.start()
+
+    def stop(self):
+        """Stop the spinner and clear the line."""
+        if not self.enabled or not self.running:
+            return # Do nothing if disabled or not running
+        self.running = False
+        if self.thread is not None:
+            self.thread.join() # Wait for the thread to finish
+        # Clear the spinner line using ANSI escape codes
+        # \r: Carriage return (move cursor to beginning of line)
+        # \033[K: Clear line from cursor to end
+        sys.stdout.write("\r\033[K")
+        sys.stdout.flush()
+        self.thread = None # Reset thread
+
+    def _spin(self):
+        """Internal method running in the spinner thread to animate."""
+        while self.running:
+            # Get the next spinner character
+            char = self.SPINNER_CHARS[self.index % len(self.SPINNER_CHARS)]
+            # Write spinner char and status, overwrite previous line content
+            try:
+                # \r moves cursor to beginning, \033[K clears the rest of the line
+                sys.stdout.write(f"\r{char} {self.status}\033[K")
+                sys.stdout.flush()
+            except BlockingIOError:
+                 # Handle potential issues if stdout is blocked (less likely for TTY)
+                 time.sleep(0.1)
+                 continue
+            self.index += 1
+            # Pause for animation effect
+            time.sleep(0.1)
+
+# Example usage (if run directly)
+if __name__ == "__main__":
+    print("Starting spinner test...")
+    s = Spinner(interactive=True) # Assume interactive for testing
+    s.start("Doing something cool")
+    try:
+        time.sleep(5) # Simulate work
+        s.stop()
+        print("Spinner stopped.")
+        s.start("Doing another thing")
+        time.sleep(3)
+    except KeyboardInterrupt:
+        print("\nInterrupted.")
+    finally:
+        s.stop() # Ensure spinner stops on exit/error
+        print("Test finished.")
+