open-swarm 0.1.1744967296__py3-none-any.whl → 0.1.1745017234__py3-none-any.whl

swarm/core/blueprint_base.py

@@ -119,24 +119,23 @@ class BlueprintBase(ABC):
     Defines the core interface for blueprint initialization and execution.
     """
     enable_terminal_commands: bool = False  # By default, terminal command execution is disabled
-
-    @classmethod
-    def main(cls):
-        """
-        Standard CLI entry point for all blueprints.
-        Subclasses can override metadata/config_path if needed.
-        """
-        from swarm.extensions.blueprint.cli_handler import run_blueprint_cli
-        from pathlib import Path
-        swarm_version = getattr(cls, "SWARM_VERSION", "1.0.0")
-        config_path = getattr(cls, "DEFAULT_CONFIG_PATH", Path(__file__).parent / "swarm_config.json")
-        run_blueprint_cli(cls, swarm_version=swarm_version, default_config_path=config_path)
+    approval_required: bool = False
+    console = Console()
+    session_logger: 'SessionLogger' = None
 
     def display_splash_screen(self, animated: bool = False):
         """Default splash screen. Subclasses can override for custom CLI/API branding."""
         console = Console()
         console.print(f"[bold cyan]Welcome to {self.__class__.__name__}![/]", style="bold")
 
+    def _load_configuration(self):
+        """
+        Loads blueprint configuration. This method is a stub for compatibility with tests that patch it.
+        In production, configuration is loaded via _load_and_process_config.
+        """
+        # You may override this in subclasses or patch in tests
+        return getattr(self, '_config', {})
+
     def __init__(self, blueprint_id: str, config: dict = None, config_path: 'Optional[Path]' = None, enable_terminal_commands: 'Optional[bool]' = None, **kwargs):
         try:
             if not blueprint_id:
@@ -195,9 +194,14 @@ class BlueprintBase(ABC):
                     if _should_debug():
                         logger.warning(f"Falling back to CLI/home config due to error: {e}")
                     # 1. CLI argument (not handled here, handled in cli_handler)
-                    # 2. Current working directory
-                    cwd_config = Path.cwd() / "swarm_config.json"
-                    if cwd_config.exists():
+                    # 2. Current working directory (guard against missing CWD)
+                    try:
+                        cwd_config = Path.cwd() / "swarm_config.json"
+                    except Exception as e:
+                        cwd_config = None
+                        if _should_debug():
+                            logger.warning(f"Unable to determine CWD for config lookup: {e}")
+                    if cwd_config and cwd_config.exists():
                         with open(cwd_config, 'r') as f:
                             self._config = json.load(f)
                     # 3. XDG_CONFIG_HOME or ~/.config/swarm/swarm_config.json
@@ -344,30 +348,36 @@ class BlueprintBase(ABC):
         if not hasattr(self, '_openai_client_cache'):
             self._openai_client_cache = {}
         if profile_name in self._model_instance_cache:
+            logger.debug(f"Using cached Model instance for profile '{profile_name}'.")
             return self._model_instance_cache[profile_name]
+        logger.debug(f"Creating new Model instance for profile '{profile_name}'.")
         profile_data = self.get_llm_profile(profile_name)
         import os
-        model_name = os.getenv("LITELLM_MODEL") or os.getenv("DEFAULT_LLM") or profile_data.get("model") or "gpt-3.5-turbo"
-        openai_kwargs = {}
-        if "base_url" in profile_data:
-            openai_kwargs["base_url"] = profile_data["base_url"]
-        if "api_key" in profile_data:
-            openai_kwargs["api_key"] = profile_data["api_key"]
-        from openai import AsyncOpenAI
-        from agents.models.openai_chatcompletions import OpenAIChatCompletionsModel
-        client_cache_key = f"{model_name}:{openai_kwargs.get('base_url','')}:key={bool(openai_kwargs.get('api_key'))}"
+        # --- PATCH: API mode selection ---
+        # Default to 'completions' mode unless 'responses' is explicitly specified in swarm_config.json for this blueprint
+        api_mode = profile_data.get("api_mode") or self.config.get("api_mode") or "completions"
+        # Allow env override for debugging if needed
+        api_mode = os.getenv("SWARM_LLM_API_MODE", api_mode)
+        model_name = os.getenv("LITELLM_MODEL") or os.getenv("DEFAULT_LLM") or profile_data.get("model")
+        provider = profile_data.get("provider", "openai")
+        client_kwargs = { "api_key": profile_data.get("api_key"), "base_url": profile_data.get("base_url") }
+        filtered_kwargs = {k: v for k, v in client_kwargs.items() if v is not None}
+        log_kwargs = {k:v for k,v in filtered_kwargs.items() if k != 'api_key'}
+        logger.debug(f"Creating new AsyncOpenAI client for '{profile_name}' with {log_kwargs} and api_mode={api_mode}")
+        client_cache_key = f"{provider}_{profile_data.get('base_url')}_{api_mode}"
         if client_cache_key not in self._openai_client_cache:
-            try:
-                self._openai_client_cache[client_cache_key] = AsyncOpenAI(**openai_kwargs)
-            except Exception as e:
-                raise ValueError(f"Failed to init client: {e}") from e
+            from openai import AsyncOpenAI
+            self._openai_client_cache[client_cache_key] = AsyncOpenAI(**filtered_kwargs)
         client = self._openai_client_cache[client_cache_key]
-        try:
+        # --- PATCH: Use correct model class based on api_mode ---
+        if api_mode == "responses":
+            from agents.models.openai_responses import OpenAIResponsesModel
+            model_instance = OpenAIResponsesModel(model=model_name, openai_client=client)
+        else:
+            from agents.models.openai_completions import OpenAIChatCompletionsModel
             model_instance = OpenAIChatCompletionsModel(model=model_name, openai_client=client)
-            self._model_instance_cache[profile_name] = model_instance
-            return model_instance
-        except Exception as e:
-            raise ValueError(f"Failed to init LLM: {e}") from e
+        self._model_instance_cache[profile_name] = model_instance
+        return model_instance
 
     def make_agent(self, name, instructions, tools, mcp_servers=None, **kwargs):
         """Factory for creating an Agent with the correct model instance from framework config."""
@@ -382,6 +392,60 @@ class BlueprintBase(ABC):
             **kwargs
         )
 
+    def request_approval(self, action_type, action_summary, action_details=None):
+        """
+        Prompt user for approval before executing an action.
+        Returns True if approved, False if rejected, or edited action if supported.
+        """
+        try:
+            from swarm.core.blueprint_ux import BlueprintUX
+            ux = BlueprintUX(style="serious")
+            box = ux.box(f"Approve {action_type}?", action_summary, summary="Details:", params=action_details)
+            self.console.print(box)
+        except Exception:
+            print(f"Approve {action_type}?\n{action_summary}\nDetails: {action_details}")
+        while True:
+            resp = input("Approve this action? [y]es/[n]o/[e]dit/[s]kip: ").strip().lower()
+            if resp in ("y", "yes"): return True
+            if resp in ("n", "no"): return False
+            if resp in ("s", "skip"): return False
+            if resp in ("e", "edit"):
+                if action_details:
+                    print("Edit not yet implemented; skipping.")
+                    return False
+                else:
+                    print("No editable content; skipping.")
+                    return False
+
+    def execute_tool_with_approval(self, tool_func, action_type, action_summary, action_details=None, *args, **kwargs):
+        if getattr(self, 'approval_required', False):
+            approved = self.request_approval(action_type, action_summary, action_details)
+            if not approved:
+                try:
+                    self.console.print(f"[yellow]Skipped {action_type}[/yellow]")
+                except Exception:
+                    print(f"Skipped {action_type}")
+                return None
+        return tool_func(*args, **kwargs)
+
+    def start_session_logger(self, blueprint_name: str, global_instructions: str = None, project_instructions: str = None):
+        from swarm.core.session_logger import SessionLogger
+        self.session_logger = SessionLogger(blueprint_name=blueprint_name)
+        self.session_logger.log_instructions(global_instructions, project_instructions)
+
+    def log_message(self, role: str, content: str):
+        if self.session_logger:
+            self.session_logger.log_message(role, content)
+
+    def log_tool_call(self, tool_name: str, result: str):
+        if self.session_logger:
+            self.session_logger.log_tool_call(tool_name, result)
+
+    def close_session_logger(self):
+        if self.session_logger:
+            self.session_logger.close()
+            self.session_logger = None
+
     @abstractmethod
     async def run(self, messages: List[Dict[str, Any]], **kwargs: Any) -> AsyncGenerator[Dict[str, Any], None]:
         """

swarm/core/blueprint_ux.py

@@ -0,0 +1,75 @@
+import time
+import itertools
+
+# Style presets
+def get_style(style):
+    if style == "serious":
+        return {
+            "border_top": "\033[1;34m╔" + "═"*50 + "╗\033[0m",
+            "border_bottom": "\033[1;34m╚" + "═"*50 + "╝\033[0m",
+            "border_side": "\033[1;34m║\033[0m",
+            "emoji": "🛠️",
+            "spinner": ['Generating.', 'Generating..', 'Generating...', 'Running...'],
+            "fallback": 'Generating... Taking longer than expected',
+        }
+    elif style == "silly":
+        return {
+            "border_top": "\033[1;35m(ﾉ◕ヮ◕)ﾉ*:･ﾟ✧" + "~"*40 + "✧ﾟ･: *ヽ(◕ヮ◕ヽ)\033[0m",
+            "border_bottom": "\033[1;35m(づ｡◕‿‿◕｡)づ" + "~"*40 + "づ(｡◕‿‿◕｡)づ\033[0m",
+            "border_side": "\033[1;35m~\033[0m",
+            "emoji": "🦆",
+            "spinner": ['Quacking.', 'Quacking..', 'Quacking...', 'Flapping...'],
+            "fallback": 'Quacking... Taking longer than expected',
+        }
+    else:
+        return get_style("serious")
+
+class BlueprintUX:
+    def __init__(self, style="serious"):
+        self.style = style
+        self._style_conf = get_style(style)
+        self._spinner_cycle = itertools.cycle(self._style_conf["spinner"])
+        self._spinner_start = None
+
+    def box(self, title, content, summary=None, result_count=None, params=None):
+        lines = []
+        border_top = self._style_conf["border_top"]
+        border_bottom = self._style_conf["border_bottom"]
+        border_side = self._style_conf["border_side"]
+        emoji = self._style_conf["emoji"]
+        lines.append(border_top)
+        lines.append(f"{border_side} {emoji} {title:<46} {border_side}")
+        if summary:
+            lines.append(f"{border_side} {summary:<48} {border_side}")
+        if result_count is not None:
+            lines.append(f"{border_side} Results: {result_count:<41} {border_side}")
+        if params:
+            lines.append(f"{border_side} Params: {params:<41} {border_side}")
+        lines.append(f"{border_side}{'':<50}{border_side}")
+        for line in content.splitlines():
+            lines.append(f"{border_side} {line[:48]:<48} {border_side}")
+        lines.append(border_bottom)
+        return "\n".join(lines)
+
+    def spinner(self, state_idx, taking_long=False):
+        if taking_long:
+            return self._style_conf["fallback"]
+        spinner_states = self._style_conf["spinner"]
+        return spinner_states[state_idx % len(spinner_states)]
+
+    def summary(self, op_type, result_count, params):
+        return f"{op_type} | Results: {result_count} | Params: {params}"
+
+    def progress(self, current, total=None):
+        if total:
+            return f"Processed {current}/{total} lines..."
+        return f"Processed {current} lines..."
+
+    def code_vs_semantic(self, result_type, results):
+        if result_type == "code":
+            header = "[Code Search Results]"
+        elif result_type == "semantic":
+            header = "[Semantic Search Results]"
+        else:
+            header = "[Results]"
+        return f"{header}\n" + "\n".join(results)

swarm/core/config_manager.py

@@ -10,11 +10,7 @@ from swarm.core.server_config import load_server_config, save_server_config
 from swarm.utils.color_utils import color_text
 from swarm.settings import DEBUG
 from swarm.core.utils.logger import *
-from swarm.extensions.cli.utils import (
-    prompt_user,
-    log_and_exit,
-    display_message
-)
+from swarm.extensions.cli.utils.prompt_user import prompt_user
 
 # Initialize logger for this module
 logger = logging.getLogger(__name__)
@@ -56,10 +52,10 @@ def backup_configuration(config_path: str) -> None:
     try:
         shutil.copy(config_path, backup_path)
         logger.info(f"Configuration backup created at '{backup_path}'")
-        display_message(f"Backup of configuration created at '{backup_path}'", "info")
+        print(f"Backup of configuration created at '{backup_path}'")
     except Exception as e:
         logger.error(f"Failed to create configuration backup: {e}")
-        display_message(f"Failed to create backup: {e}", "error")
+        print(f"Failed to create backup: {e}")
         sys.exit(1)
 
 def load_config(config_path: str) -> Dict[str, Any]:
@@ -82,11 +78,11 @@ def load_config(config_path: str) -> Dict[str, Any]:
             logger.debug(f"Raw configuration loaded: {config}")
     except FileNotFoundError:
         logger.error(f"Configuration file not found at {config_path}")
-        display_message(f"Configuration file not found at {config_path}", "error")
+        print(f"Configuration file not found at {config_path}")
         sys.exit(1)
     except json.JSONDecodeError as e:
         logger.error(f"Invalid JSON in configuration file {config_path}: {e}")
-        display_message(f"Invalid JSON in configuration file {config_path}: {e}", "error")
+        print(f"Invalid JSON in configuration file {config_path}: {e}")
         sys.exit(1)
 
     # Resolve placeholders recursively
@@ -95,7 +91,7 @@ def load_config(config_path: str) -> Dict[str, Any]:
         logger.debug(f"Configuration after resolving placeholders: {resolved_config}")
     except Exception as e:
         logger.error(f"Failed to resolve placeholders in configuration: {e}")
-        display_message(f"Failed to resolve placeholders in configuration: {e}", "error")
+        print(f"Failed to resolve placeholders in configuration: {e}")
         sys.exit(1)
 
     return resolved_config
@@ -115,10 +111,10 @@ def save_config(config_path: str, config: Dict[str, Any]) -> None:
         with open(config_path, "w") as f:
             json.dump(config, f, indent=4)
         logger.info(f"Configuration saved to '{config_path}'")
-        display_message(f"Configuration saved to '{config_path}'", "info")
+        print(f"Configuration saved to '{config_path}'")
     except Exception as e:
         logger.error(f"Failed to save configuration: {e}")
-        display_message(f"Failed to save configuration: {e}", "error")
+        print(f"Failed to save configuration: {e}")
         sys.exit(1)
 
 def add_llm(config_path: str) -> None:
@@ -129,20 +125,20 @@ def add_llm(config_path: str) -> None:
         config_path (str): Path to the configuration file.
     """
     config = load_config(config_path)
-    display_message("Starting the process to add a new LLM.", "info")
+    print("Starting the process to add a new LLM.")
 
     while True:
         llm_name = prompt_user("Enter the name of the new LLM (or type 'done' to finish)").strip()
-        display_message(f"User entered LLM name: {llm_name}", "info")
+        print(f"User entered LLM name: {llm_name}")
         if llm_name.lower() == 'done':
-            display_message("Finished adding LLMs.", "info")
+            print("Finished adding LLMs.")
             break
         if not llm_name:
-            display_message("LLM name cannot be empty.", "error")
+            print("LLM name cannot be empty.")
             continue
 
         if llm_name in config.get("llm", {}):
-            display_message(f"LLM '{llm_name}' already exists.", "warning")
+            print(f"LLM '{llm_name}' already exists.")
             continue
 
         llm = {}
@@ -158,16 +154,16 @@ def add_llm(config_path: str) -> None:
             temperature_input = prompt_user("Enter the temperature (e.g., 0.7)").strip()
             llm["temperature"] = float(temperature_input)
         except ValueError:
-            display_message("Invalid temperature value. Using default 0.7.", "warning")
+            print("Invalid temperature value. Using default 0.7.")
             llm["temperature"] = 0.7
 
         config.setdefault("llm", {})[llm_name] = llm
         logger.info(f"Added LLM '{llm_name}' to configuration.")
-        display_message(f"LLM '{llm_name}' added.", "info")
+        print(f"LLM '{llm_name}' added.")
 
     backup_configuration(config_path)
     save_config(config_path, config)
-    display_message("LLM configuration process completed.", "info")
+    print("LLM configuration process completed.")
 
 def remove_llm(config_path: str, llm_name: str) -> None:
     """
@@ -180,18 +176,18 @@ def remove_llm(config_path: str, llm_name: str) -> None:
     config = load_config(config_path)
 
     if llm_name not in config.get("llm", {}):
-        display_message(f"LLM '{llm_name}' does not exist.", "error")
+        print(f"LLM '{llm_name}' does not exist.")
         return
 
     confirm = prompt_user(f"Are you sure you want to remove LLM '{llm_name}'? (yes/no)").strip().lower()
     if confirm not in ['yes', 'y']:
-        display_message("Operation cancelled.", "warning")
+        print("Operation cancelled.")
         return
 
     del config["llm"][llm_name]
     backup_configuration(config_path)
     save_config(config_path, config)
-    display_message(f"LLM '{llm_name}' has been removed.", "info")
+    print(f"LLM '{llm_name}' has been removed.")
     logger.info(f"Removed LLM '{llm_name}' from configuration.")
 
 def add_mcp_server(config_path: str) -> None:
@@ -202,20 +198,20 @@ def add_mcp_server(config_path: str) -> None:
         config_path (str): Path to the configuration file.
     """
     config = load_config(config_path)
-    display_message("Starting the process to add a new MCP server.", "info")
+    print("Starting the process to add a new MCP server.")
 
     while True:
         server_name = prompt_user("Enter the name of the new MCP server (or type 'done' to finish)").strip()
-        display_message(f"User entered MCP server name: {server_name}", "info")
+        print(f"User entered MCP server name: {server_name}")
         if server_name.lower() == 'done':
-            display_message("Finished adding MCP servers.", "info")
+            print("Finished adding MCP servers.")
             break
         if not server_name:
-            display_message("Server name cannot be empty.", "error")
+            print("Server name cannot be empty.")
             continue
 
         if server_name in config.get("mcpServers", {}):
-            display_message(f"MCP server '{server_name}' already exists.", "warning")
+            print(f"MCP server '{server_name}' already exists.")
             continue
 
         server = {}
@@ -226,7 +222,7 @@ def add_mcp_server(config_path: str) -> None:
             if not isinstance(server["args"], list):
                 raise ValueError
         except ValueError:
-            display_message("Invalid arguments format. Using an empty list.", "warning")
+            print("Invalid arguments format. Using an empty list.")
             server["args"] = []
 
         env_vars = {}
@@ -242,11 +238,11 @@ def add_mcp_server(config_path: str) -> None:
 
         config.setdefault("mcpServers", {})[server_name] = server
         logger.info(f"Added MCP server '{server_name}' to configuration.")
-        display_message(f"MCP server '{server_name}' added.", "info")
+        print(f"MCP server '{server_name}' added.")
 
     backup_configuration(config_path)
     save_config(config_path, config)
-    display_message("MCP server configuration process completed.", "info")
+    print("MCP server configuration process completed.")
 
 def remove_mcp_server(config_path: str, server_name: str) -> None:
     """
@@ -259,16 +255,16 @@ def remove_mcp_server(config_path: str, server_name: str) -> None:
     config = load_config(config_path)
 
     if server_name not in config.get("mcpServers", {}):
-        display_message(f"MCP server '{server_name}' does not exist.", "error")
+        print(f"MCP server '{server_name}' does not exist.")
         return
 
     confirm = prompt_user(f"Are you sure you want to remove MCP server '{server_name}'? (yes/no)").strip().lower()
     if confirm not in ['yes', 'y']:
-        display_message("Operation cancelled.", "warning")
+        print("Operation cancelled.")
         return
 
     del config["mcpServers"][server_name]
     backup_configuration(config_path)
     save_config(config_path, config)
-    display_message(f"MCP server '{server_name}' has been removed.", "info")
+    print(f"MCP server '{server_name}' has been removed.")
     logger.info(f"Removed MCP server '{server_name}' from configuration.")

swarm/core/output_utils.py

@@ -70,10 +70,10 @@ def ansi_box(title: str, content: str, color: str = "94", emoji: str = "🔎", b
 def print_search_box(title: str, content: str, color: str = "94", emoji: str = "🔎"):
     print(ansi_box(title, content, color=color, emoji=emoji))
 
-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."""
+def pretty_print_response(messages: List[Dict[str, Any]], use_markdown: bool = False, spinner=None, agent_name: str = None) -> None:
+    """Format and print messages, optionally rendering assistant content as markdown, and always prefixing agent responses with the agent's name."""
     # --- DEBUG PRINT ---
-    print(f"\n[DEBUG pretty_print_response called with {len(messages)} messages, use_markdown={use_markdown}]", flush=True)
+    print(f"\n[DEBUG pretty_print_response called with {len(messages)} messages, use_markdown={use_markdown}, agent_name={agent_name}]", flush=True)
 
     if spinner:
         spinner.stop()
@@ -85,7 +85,7 @@ def pretty_print_response(messages: List[Dict[str, Any]], use_markdown: bool = F
         return
 
     for i, msg in enumerate(messages):
-         # --- DEBUG PRINT ---
+        # --- 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)
@@ -98,20 +98,20 @@ def pretty_print_response(messages: List[Dict[str, Any]], use_markdown: bool = F
         # --- 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)
+            # Use agent_name if provided, else sender, else 'assistant'
+            display_name = agent_name or sender or "assistant"
+            # Magenta for agent output
+            print(f"\033[95m[{display_name}]\033[0m: ", end="", flush=True)
             if msg_content:
-                 # --- DEBUG PRINT ---
+                # --- 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, flush=True)
             elif not tool_calls:
-                print(flush=True) # Flush newline if no content/tools
+                print(flush=True)
 
             if tool_calls and isinstance(tool_calls, list):
                 print("  \033[92mTool Calls:\033[0m", flush=True)

swarm/core/session_logger.py

@@ -0,0 +1,42 @@
+import os
+import datetime
+from typing import Optional, List, Dict
+
+class SessionLogger:
+    def __init__(self, blueprint_name: str, log_dir: Optional[str] = None):
+        if log_dir is None:
+            base_dir = os.path.dirname(__file__)
+            log_dir = os.path.join(base_dir, f"../blueprints/{blueprint_name}/session_logs")
+        os.makedirs(log_dir, exist_ok=True)
+        self.log_dir = log_dir
+        self.session_time = datetime.datetime.now().strftime("%Y-%m-%dT%H-%M-%S")
+        self.log_path = os.path.join(log_dir, f"session_{self.session_time}.md")
+        self._open_log()
+
+    def _open_log(self):
+        self.log_file = open(self.log_path, "w")
+        self.log_file.write(f"# Session Log\n\nStarted: {self.session_time}\n\n")
+        self.log_file.flush()
+
+    def log_instructions(self, global_instructions: Optional[str], project_instructions: Optional[str]):
+        self.log_file.write("## Instructions\n")
+        if global_instructions:
+            self.log_file.write("### Global Instructions\n" + global_instructions + "\n\n")
+        if project_instructions:
+            self.log_file.write("### Project Instructions\n" + project_instructions + "\n\n")
+        self.log_file.write("## Messages\n")
+        self.log_file.flush()
+
+    def log_message(self, role: str, content: str, agent_name: str = None):
+        # Log agent name if provided, else fallback to role
+        display_name = agent_name or role
+        self.log_file.write(f"- **{display_name}**: {content}\n")
+        self.log_file.flush()
+
+    def log_tool_call(self, tool_name: str, result: str):
+        self.log_file.write(f"- **assistant (tool:{tool_name})**: {result}\n")
+        self.log_file.flush()
+
+    def close(self):
+        self.log_file.write(f"\nEnded: {datetime.datetime.now().strftime('%Y-%m-%dT%H-%M-%S')}\n")
+        self.log_file.close()

swarm/core/slash_commands.py

@@ -15,3 +15,48 @@ class SlashCommandRegistry:
         return self.commands.get(command)
 
 slash_registry = SlashCommandRegistry()
+# Built-in '/help' slash command
+@slash_registry.register('/help')
+def _help_command(blueprint=None, args=None):
+    """List available slash commands."""
+    cmds = sorted(slash_registry.commands.keys())
+    return "Available slash commands:\n" + "\n".join(cmds)
+
+# Built-in '/compact' slash command
+@slash_registry.register('/compact')
+def _compact_command(blueprint=None, args=None):
+    """Placeholder for compacting conversation context."""
+    return "[slash command] compact summary not implemented yet."
+
+# Built-in '/model' slash command
+@slash_registry.register('/model')
+def _model_command(blueprint=None, args=None):
+    """Show or switch the current LLM model."""
+    if args:
+        return f"[slash command] model switch not implemented. Requested: {args}"
+    profile = getattr(blueprint, 'llm_profile_name', None)
+    return f"[slash command] current LLM profile: {profile or 'unknown'}"
+
+# Built-in '/approval' slash command
+@slash_registry.register('/approval')
+def _approval_command(blueprint=None, args=None):
+    """Toggle or display auto-approval mode."""
+    return "[slash command] approval mode not implemented yet."
+
+# Built-in '/history' slash command
+@slash_registry.register('/history')
+def _history_command(blueprint=None, args=None):
+    """Display session history of commands and files."""
+    return "[slash command] history not implemented yet."
+
+# Built-in '/clear' slash command
+@slash_registry.register('/clear')
+def _clear_command(blueprint=None, args=None):
+    """Clear the screen and current context."""
+    return "[slash command] context cleared."
+
+# Built-in '/clearhistory' slash command
+@slash_registry.register('/clearhistory')
+def _clearhistory_command(blueprint=None, args=None):
+    """Clear the command history."""
+    return "[slash command] command history cleared."