open-swarm 0.1.1745275181__py3-none-any.whl → 0.1.1748636295__py3-none-any.whl

swarm/extensions/blueprint/interactive_mode.py

@@ -3,10 +3,12 @@ Interactive mode logic for blueprint extensions.
 """
 
 import logging
-from typing import List, Dict, Any # Added Any
+from typing import List, Dict
 
 # Import the standalone output function
 from .output_utils import pretty_print_response
+# Assuming spinner is managed by the blueprint instance passed in
+# from .spinner import Spinner # Not needed directly here
 
 logger = logging.getLogger(__name__)
 
@@ -14,32 +16,24 @@ 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.
+    This function implements the interactive loop where the user is prompted for input,
+    and responses are generated and printed using the blueprint instance's methods.
     """
     logger.debug("Starting interactive mode.")
-    if not blueprint.starting_agent:
+    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]] = []
+    messages: List[Dict[str, str]] = []
     first_input = True
     message_count = 0
     while True:
+        # Use the blueprint's spinner instance if it exists
         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 spinner:
+            spinner.stop()
 
+        user_input = input(blueprint.prompt).strip()
         if user_input.lower() in {"exit", "quit", "/quit"}:
             print("Exiting interactive mode.")
             break
@@ -49,54 +43,65 @@ ance's methods.
         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}]")
+        # run_with_context should handle its own spinner start/stop now
+        result = blueprint.run_with_context(messages, blueprint.context_variables)
+        swarm_response = result["response"]
+
+        # Determine response messages
+        response_messages = []
+        if hasattr(swarm_response, 'messages'):
+            response_messages = swarm_response.messages
+        elif isinstance(swarm_response, dict) and 'messages' in swarm_response:
+            response_messages = swarm_response.get('messages', [])
+
+        # Process output
+        if stream:
+            # Assuming _process_and_print_streaming_response_async exists on blueprint
+            # This might also need updating if it relies on the old print method
+            try:
+                import asyncio
+                asyncio.run(blueprint._process_and_print_streaming_response_async(swarm_response))
+            except AttributeError:
+                 logger.error("Blueprint instance missing '_process_and_print_streaming_response_async' method for streaming.")
+                 print("[Error: Streaming output failed]")
+            except Exception as e:
+                 logger.error(f"Error during streaming output: {e}", exc_info=True)
+                 print("[Error during streaming output]")
+
+        else:
+            # Use the imported pretty_print_response function
+            pretty_print_response(
+                response_messages,
+                use_markdown=getattr(blueprint, 'use_markdown', False),
+                spinner=spinner # Pass the spinner instance
+            )
+
+        # Extend history and handle post-response logic
+        messages.extend(response_messages)
+
+        # Check for goal update logic
+        if getattr(blueprint, 'update_user_goal', False) and \
+           (message_count - getattr(blueprint, 'last_goal_update_count', 0)) >= \
+           getattr(blueprint, 'update_user_goal_frequency', 5):
+            # Assume _update_user_goal is an async method on blueprint
+            try:
+                import asyncio
+                asyncio.run(blueprint._update_user_goal_async(messages))
+                blueprint.last_goal_update_count = message_count
+            except AttributeError:
+                logger.warning("Blueprint instance missing '_update_user_goal_async' method.")
+            except Exception as e:
+                logger.error(f"Error updating user goal: {e}", exc_info=True)
+
+
+        # Check for auto-complete logic
+        if getattr(blueprint, 'auto_complete_task', False):
+            # Assume _auto_complete_task is an async method on blueprint
+            try:
+                import asyncio
+                asyncio.run(blueprint._auto_complete_task_async(messages, stream))
+            except AttributeError:
+                 logger.warning("Blueprint instance missing '_auto_complete_task_async' method.")
+            except Exception as e:
+                 logger.error(f"Error during auto-complete task: {e}", exc_info=True)
 

swarm/extensions/blueprint/output_utils.py

@@ -0,0 +1,82 @@
+"""
+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."""
+    if not RICH_AVAILABLE:
+        print(content)
+        return
+    console = Console()
+    md = Markdown(content)
+    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."""
+    if spinner:
+        spinner.stop()
+        sys.stdout.write("\r\033[K")
+        sys.stdout.flush()
+
+    if not messages:
+        logger.debug("No messages to print in pretty_print_response.")
+        return
+
+    for msg in messages:
+        if not isinstance(msg, dict):
+            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")
+
+        if role == "assistant":
+            print(f"\033[94m{sender}\033[0m: ", end="")
+            if msg_content:
+                if use_markdown and RICH_AVAILABLE:
+                    render_markdown(msg_content)
+                else:
+                    print(msg_content)
+            elif not tool_calls:
+                print()
+
+            if tool_calls and isinstance(tool_calls, list):
+                print("  \033[92mTool Calls:\033[0m")
+                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})")
+
+        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) + '    ')}")

swarm/{core → extensions/blueprint}/spinner.py

@@ -6,36 +6,29 @@ import os
 import sys
 import threading
 import time
-from typing import Optional
 
 class Spinner:
     """Simple terminal spinner for interactive feedback."""
     # Define spinner characters (can be customized)
     SPINNER_CHARS = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏']
-    # Custom status sequences for special cases
-    STATUS_SEQUENCES = {
-        'generating': ['Generating.', 'Generating..', 'Generating...'],
-        'running': ['Running...']
-    }
+    # SPINNER_CHARS = ['|', '/', '-', '\\'] # Simpler alternative
 
-    def __init__(self, interactive: bool, custom_sequence: str = None):
+    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.
-            custom_sequence (str): Optional name for a custom status sequence (e.g., 'generating', 'running').
         """
         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
-        self.custom_sequence = custom_sequence
-        self.sequence_idx = 0
 
     def start(self, status: str = "Processing..."):
         """Start the spinner with an optional status message."""
@@ -43,7 +36,7 @@ class Spinner:
             return # Do nothing if disabled or already running
         self.status = status
         self.running = True
-        self.sequence_idx = 0
+        # Run the spinner animation in a separate daemon thread
         self.thread = threading.Thread(target=self._spin, daemon=True)
         self.thread.start()
 
@@ -54,33 +47,30 @@ class Spinner:
         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
+        self.thread = None # Reset thread
 
     def _spin(self):
         """Internal method running in the spinner thread to animate."""
-        start_time = time.time()
-        warned = False
         while self.running:
-            elapsed = time.time() - start_time
-            if self.custom_sequence and self.custom_sequence in self.STATUS_SEQUENCES:
-                seq = self.STATUS_SEQUENCES[self.custom_sequence]
-                # If taking longer than 10s, show special message
-                if elapsed > 10 and not warned:
-                    msg = f"{seq[-1]} Taking longer than expected"
-                    warned = True
-                else:
-                    msg = seq[self.sequence_idx % len(seq)]
-                sys.stdout.write(f"\r{msg}\033[K")
-                sys.stdout.flush()
-                self.sequence_idx += 1
-            else:
-                char = self.SPINNER_CHARS[self.index % len(self.SPINNER_CHARS)]
+            # 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()
-                self.index += 1
-            time.sleep(0.4 if self.custom_sequence else 0.1)
+            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__":
@@ -98,3 +88,4 @@ if __name__ == "__main__":
     finally:
         s.stop() # Ensure spinner stops on exit/error
         print("Test finished.")
+

swarm/extensions/cli/cli_args.py

@@ -1,14 +1,8 @@
 # src/swarm/extensions/blueprint/modes/cli_mode/cli_args.py
 
 import argparse
-import os
-import sys
 from typing import Namespace
 
-# --- DEBUG PRINTS REMOVED BY CASCADE ---
-# print(f"[DEBUG] cli_args.py startup: sys.argv={sys.argv}")
-# print(f"[DEBUG] cli_args.py startup: LITELLM_MODEL={os.environ.get('LITELLM_MODEL')}, DEFAULT_LLM={os.environ.get('DEFAULT_LLM')}")
-
 def parse_arguments() -> Namespace:
     """
     Parse command-line arguments for dynamic LLM configuration, MCP server management, and other overrides.

swarm/extensions/cli/commands/blueprint_management.py

@@ -1,7 +1,7 @@
 # Handles blueprint discovery and validation for the CLI
 
-from swarm.core.blueprint_discovery import discover_blueprints
-# from swarm.core.config_loader import load_server_config  # Removed: function does not exist
+from swarm.extensions.blueprint.discovery import discover_blueprints
+from swarm.extensions.config.config_loader import load_server_config
 
 def list_blueprints():
     """List available blueprints and their metadata."""
@@ -13,57 +13,19 @@ def list_blueprints():
     for name, metadata in blueprints.items():
         print(f"- {name}: {metadata.get('description', 'No description available.')}")
 
-def enable_blueprint(blueprint_name):
-    """
-    Enable a blueprint by adding it to config and creating a CLI symlink.
-    """
-    import json
-    import os
-    from pathlib import Path
-    CONFIG_PATH = os.path.expanduser("~/.config/swarm/swarm_config.json")
-    BIN_DIR = os.path.expanduser("~/.local/bin")
-    BP_RUNNER = os.path.join(os.path.dirname(__file__), "../../../../src/swarm/blueprints/{}/blueprint_{}.py".format(blueprint_name, blueprint_name))
-    CLI_SYMLINK = os.path.join(BIN_DIR, blueprint_name)
-
-    # Load config
-    with open(CONFIG_PATH, "r") as f:
-        config = json.load(f)
-    enabled = config.get("blueprints", {}).get("enabled", [])
-    if blueprint_name in enabled:
-        print(f"Blueprint '{blueprint_name}' is already enabled.")
-        return
-    # Add to config
-    enabled.append(blueprint_name)
-    if "blueprints" not in config:
-        config["blueprints"] = {}
-    config["blueprints"]["enabled"] = enabled
-    with open(CONFIG_PATH, "w") as f:
-        json.dump(config, f, indent=2)
-    # Ensure bin dir exists
-    os.makedirs(BIN_DIR, exist_ok=True)
-    # Create symlink (Python runner)
-    if not os.path.isfile(BP_RUNNER):
-        print(f"Blueprint runner not found: {BP_RUNNER}")
-        return
-    # Write a .sh launcher wrapper for .py if not present
-    CLI_WRAPPER = CLI_SYMLINK
-    with open(CLI_WRAPPER, "w") as f:
-        f.write(f"#!/usr/bin/env bash\nexec python3 '{os.path.abspath(BP_RUNNER)}' \"$@\"")
-    os.chmod(CLI_WRAPPER, 0o755)
-    print(f"Enabled blueprint '{blueprint_name}'. CLI utility installed at {CLI_WRAPPER}.")
-
+cat > src/swarm/extensions/cli/commands/config_management.py << 'EOF'
 # Handles configuration management workflows (e.g., LLM, MCP servers)
 
-# from swarm.core.config_loader import (
-#     load_server_config,
-#     save_server_config,
-# )
+from swarm.extensions.config.config_loader import (
+    load_server_config,
+    save_server_config,
+)
 
 def add_llm(model_name, api_key):
     """Add a new LLM configuration."""
-    config = {}  # load_server_config()
+    config = load_server_config()
     if "llms" not in config:
         config["llms"] = {}
     config["llms"][model_name] = {"api_key": api_key}
-    # save_server_config(config)
+    save_server_config(config)
     print(f"Added LLM '{model_name}' to configuration.")

swarm/extensions/cli/commands/config_management.py

@@ -1,14 +1,15 @@
 # Handles configuration management workflows (e.g., LLM, MCP servers)
 
-from swarm.core import config_loader
-from swarm.core import config_manager
-from swarm.core import server_config
+from swarm.extensions.config.config_loader import (
+    load_server_config,
+    save_server_config,
+)
 
 def add_llm(model_name, api_key):
     """Add a new LLM configuration."""
-    config = config_loader.load_server_config()
+    config = load_server_config()
     if "llms" not in config:
         config["llms"] = {}
     config["llms"][model_name] = {"api_key": api_key}
-    config_manager.save_server_config(config)
+    save_server_config(config)
     print(f"Added LLM '{model_name}' to configuration.")

swarm/extensions/cli/commands/edit_config.py

@@ -1,21 +1,12 @@
 import argparse
 import json
-from swarm.core import (
-    config_loader,
-    config_manager,
-    server_config,
-    setup_wizard,
+from swarm.extensions.config.config_loader import (
+    load_server_config,
+    save_server_config,
 )
 from pathlib import Path
-import os
 
-def get_xdg_config_path():
-    config_home = os.environ.get("XDG_CONFIG_HOME", str(Path.home() / ".config"))
-    config_dir = Path(config_home) / "swarm"
-    config_dir.mkdir(parents=True, exist_ok=True)
-    return config_dir / "swarm_config.json"
-
-CONFIG_PATH = get_xdg_config_path()
+CONFIG_PATH = Path("swarm_config.json").resolve()
 
 def list_config(config):
     """
@@ -69,7 +60,7 @@ def main():
     args = parser.parse_args()
 
     try:
-        config = config_loader.load_server_config(str(CONFIG_PATH))
+        config = load_server_config(str(CONFIG_PATH))
     except FileNotFoundError as e:
         print(f"Error: {e}")
         return
@@ -78,9 +69,9 @@ def main():
         list_config(config)
     elif args.interactive:
         edit_config_interactive(config)
-        config_loader.save_server_config(str(CONFIG_PATH), config)
+        save_server_config(str(CONFIG_PATH), config)
     elif args.field and args.value:
         edit_config_field(config, args.field, args.value)
-        config_loader.save_server_config(str(CONFIG_PATH), config)
+        save_server_config(str(CONFIG_PATH), config)
     else:
         parser.print_help()

swarm/extensions/cli/commands/list_blueprints.py

@@ -4,7 +4,7 @@ Description: Lists all blueprints available in the system.
 """
 
 from pathlib import Path
-from swarm.core.blueprint_discovery import discover_blueprints
+from swarm.extensions.blueprint.blueprint_discovery import discover_blueprints
 
 # Metadata for dynamic registration
 description = "Lists all blueprints available in the system."

swarm/extensions/cli/commands/validate_env.py

@@ -1,16 +1,9 @@
 import os
 import argparse
-from pathlib import Path
-from swarm.core import config_loader, config_manager, server_config
-from swarm.core.blueprint_base import BlueprintBase
+from swarm.extensions.config.config_loader import load_server_config
+from swarm.extensions.blueprint.blueprint_base import BlueprintBase
 
-def get_xdg_config_path():
-    config_home = os.environ.get("XDG_CONFIG_HOME", str(Path.home() / ".config"))
-    config_dir = Path(config_home) / "swarm"
-    config_dir.mkdir(parents=True, exist_ok=True)
-    return config_dir / "swarm_config.json"
-
-CONFIG_PATH = str(get_xdg_config_path())
+CONFIG_PATH = "swarm_config.json"
 
 def validate_all_env_vars(config):
     """
@@ -50,7 +43,7 @@ def main():
     args = parser.parse_args()
 
     try:
-        config = server_config.load_server_config(CONFIG_PATH)
+        config = load_server_config(CONFIG_PATH)
     except FileNotFoundError as e:
         print(f"Error: {e}")
         return

swarm/extensions/cli/commands/validate_envvars.py

@@ -1,5 +1,5 @@
-from swarm.core.blueprint_discovery import discover_blueprints
-from swarm.core import config_loader, config_manager, server_config
+from swarm.extensions.blueprint.blueprint_discovery import discover_blueprints
+from swarm.extensions.config.config_loader import load_env_config, validate_env_vars
 import argparse
 
 def validate_envvars(blueprint_name=None):
@@ -19,16 +19,16 @@ def validate_envvars(blueprint_name=None):
             print(f"Blueprint '{blueprint_name}' not found.")
             return
         required_vars = blueprint.get("env_vars", [])
-        env_vars = config_loader.load_env_config()
-        validation = config_manager.validate_env_vars(env_vars, required_vars)
+        env_vars = load_env_config()
+        validation = validate_env_vars(env_vars, required_vars)
         print(f"Validation for '{blueprint_name}': {validation}")
     else:
         # Global validation
-        env_vars = config_loader.load_env_config()
+        env_vars = load_env_config()
         print("Global Environment Validation:")
         for blueprint_name, blueprint_data in blueprints.items():
             required_vars = blueprint_data.get("env_vars", [])
-            validation = config_manager.validate_env_vars(env_vars, required_vars)
+            validation = validate_env_vars(env_vars, required_vars)
             print(f"Validation for '{blueprint_name}': {validation}")
 
 def main():

swarm/extensions/cli/interactive_shell.py

@@ -35,21 +35,7 @@ def interactive_shell():
             break
 
 def show_help(commands):
-    """Display available commands with helpful context and usage."""
-    print("\n\033[1;36mSwarm CLI Help\033[0m")
-    print("Type the command name to run it, or 'exit' to quit.")
-    print("Commands can be used to manage your Swarm config, blueprints, LLMs, MCP servers, and more.\n")
+    """Display available commands."""
     print("Available commands:")
     for cmd, metadata in commands.items():
-        desc = metadata.get('description', 'No description provided.')
-        usage = metadata.get('usage', None)
-        print(f"  \033[1;33m{cmd}\033[0m: {desc}")
-        if usage:
-            print(f"    Usage: {usage}")
-    print("\nExamples:")
-    print("  validate_envvars    # Check required environment variables")
-    print("  edit_config         # Edit your Swarm config interactively")
-    print("  list_blueprints     # List all available blueprints")
-    print("  blueprint_management # Advanced blueprint management")
-    print("  config_management   # Manage LLMs, MCP servers, blueprints")
-    print("\nType 'exit' to leave the shell.\n")
+        print(f" - {cmd}: {metadata['description']}")