open-swarm 0.1.1745125933__py3-none-any.whl → 0.1.1745126277__py3-none-any.whl

swarm/blueprints/divine_code/blueprint_divine_code.py

@@ -8,6 +8,7 @@ import logging
 import os
 import sys
 from typing import Dict, Any, List, ClassVar, Optional
+from swarm.blueprints.common.operation_box_utils import display_operation_box
 
 # Ensure src is in path for BlueprintBase import
 project_root = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..'))
@@ -24,6 +25,10 @@ try:
     from openai import AsyncOpenAI
     from swarm.core.blueprint_base import BlueprintBase
     from swarm.core.blueprint_ux import BlueprintUX
+    from rich.console import Console
+    from rich.text import Text
+    from rich.style import Style
+    import threading, time
 except ImportError as e:
     print(f"ERROR: Import failed in DivineOpsBlueprint: {e}. Check 'openai-agents' install and project structure.")
     print(f"sys.path: {sys.path}")
@@ -121,8 +126,84 @@ Available MCP Tools (if provided): sequential-thinking, filesystem.
 You also have fileops capabilities: read_file, write_file, list_files, execute_shell_command.
 """
 
-# Spinner UX enhancement (Open Swarm TODO)
-SPINNER_STATES = ['Generating.', 'Generating..', 'Generating...', 'Running...']
+# --- Spinner and ANSI/emoji operation box for unified UX ---
+from swarm.ux.ansi_box import ansi_box
+from rich.console import Console
+from rich.style import Style
+from rich.text import Text
+
+# Patch Spinner to match Open Swarm UX (FRAMES, slow warning, etc.)
+class DivineOpsSpinner:
+    FRAMES = [
+        "Generating.", "Generating..", "Generating...", "Running...",
+        "⠋ Generating...", "⠙ Generating...", "⠹ Generating...", "⠸ Generating...",
+        "⠼ Generating...", "⠴ Generating...", "⠦ Generating...", "⠧ Generating...",
+        "⠇ Generating...", "⠏ Generating...", "🤖 Generating...", "💡 Generating...", "✨ Generating..."
+    ]
+    SLOW_FRAME = "Generating... Taking longer than expected"
+    INTERVAL = 0.12
+    SLOW_THRESHOLD = 10  # seconds
+
+    def __init__(self):
+        import threading, time
+        self._stop_event = threading.Event()
+        self._thread = None
+        self._start_time = None
+        self.console = Console()
+        self._last_frame = None
+        self._last_slow = False
+
+    def start(self):
+        import time
+        self._stop_event.clear()
+        self._start_time = time.time()
+        import threading
+        self._thread = threading.Thread(target=self._spin, daemon=True)
+        self._thread.start()
+
+    def _spin(self):
+        import time
+        idx = 0
+        while not self._stop_event.is_set():
+            elapsed = time.time() - self._start_time
+            if elapsed > self.SLOW_THRESHOLD:
+                txt = Text(self.SLOW_FRAME, style=Style(color="yellow", bold=True))
+                self._last_frame = self.SLOW_FRAME
+                self._last_slow = True
+            else:
+                frame = self.FRAMES[idx % len(self.FRAMES)]
+                txt = Text(frame, style=Style(color="cyan", bold=True))
+                self._last_frame = frame
+                self._last_slow = False
+            self.console.print(txt, end="\r", soft_wrap=True, highlight=False)
+            time.sleep(self.INTERVAL)
+            idx += 1
+        self.console.print(" " * 40, end="\r")  # Clear line
+
+    def stop(self, final_message="Done!"):
+        self._stop_event.set()
+        if self._thread:
+            self._thread.join()
+        self.console.print(Text(final_message, style=Style(color="green", bold=True)))
+
+    def current_spinner_state(self):
+        if self._last_slow:
+            return self.SLOW_FRAME
+        return self._last_frame or self.FRAMES[0]
+
+
+def print_operation_box(op_type, results, params=None, result_type="divine", taking_long=False):
+    emoji = "⚡" if result_type == "divine" else "🔍"
+    style = 'success' if result_type == "divine" else 'default'
+    box_title = op_type if op_type else ("Divine Output" if result_type == "divine" else "Results")
+    summary_lines = []
+    count = len(results) if isinstance(results, list) else 0
+    summary_lines.append(f"Results: {count}")
+    if params:
+        for k, v in params.items():
+            summary_lines.append(f"{k.capitalize()}: {v}")
+    box_content = "\n".join(summary_lines + ["\n".join(map(str, results))])
+    ansi_box(box_title, box_content, count=count, params=params, style=style if not taking_long else 'warning', emoji=emoji)
 
 # --- FileOps Tool Logic Definitions ---
  # Patch: Expose underlying fileops functions for direct testing
@@ -149,12 +230,28 @@ def list_files(directory: str = '.') -> str:
     except Exception as e:
         return f"ERROR: {e}"
 def execute_shell_command(command: str) -> str:
-    import subprocess
+    """
+    Executes a shell command and returns its stdout and stderr.
+    Timeout is configurable via SWARM_COMMAND_TIMEOUT (default: 60s).
+    """
+    logger.info(f"Executing shell command: {command}")
     try:
-        result = subprocess.run(command, shell=True, capture_output=True, text=True)
-        return result.stdout + result.stderr
+        import os
+        timeout = int(os.getenv("SWARM_COMMAND_TIMEOUT", "60"))
+        result = subprocess.run(command, shell=True, capture_output=True, text=True, timeout=timeout)
+        output = f"Exit Code: {result.returncode}\n"
+        if result.stdout:
+            output += f"STDOUT:\n{result.stdout}\n"
+        if result.stderr:
+            output += f"STDERR:\n{result.stderr}\n"
+        logger.info(f"Command finished. Exit Code: {result.returncode}")
+        return output.strip()
+    except subprocess.TimeoutExpired:
+        logger.error(f"Command timed out: {command}")
+        return f"Error: Command timed out after {os.getenv('SWARM_COMMAND_TIMEOUT', '60')} seconds."
     except Exception as e:
-        return f"ERROR: {e}"
+        logger.error(f"Error executing command '{command}': {e}", exc_info=True)
+        return f"Error executing command: {e}"
 read_file_tool = PatchedFunctionTool(read_file, 'read_file')
 write_file_tool = PatchedFunctionTool(write_file, 'write_file')
 list_files_tool = PatchedFunctionTool(list_files, 'list_files')
@@ -166,6 +263,36 @@ class DivineOpsBlueprint(BlueprintBase):
         super().__init__(blueprint_id, config_path=config_path, **kwargs)
         # Use serious style for DivineOps
         self.ux = BlueprintUX(style="serious")
+        # Spinner for pantheon operations
+        self._spinner = None
+
+    class Spinner:
+        FRAMES = [
+            "⚡ Summoning Pantheon...",
+            "🔥 Forging Tools...",
+            "🌩️ Commanding Zeus...",
+            "✨ Awakening Divinity..."
+        ]
+        INTERVAL = 0.15
+        def __init__(self):
+            self._stop = threading.Event()
+            self._thread = threading.Thread(target=self._spin, daemon=True)
+            self._idx = 0
+            self.console = Console()
+        def start(self):
+            self._stop.clear()
+            self._thread.start()
+        def _spin(self):
+            while not self._stop.is_set():
+                frame = DivineOpsBlueprint.Spinner.FRAMES[self._idx % len(DivineOpsBlueprint.Spinner.FRAMES)]
+                self.console.print(Text(frame, style=Style(color="magenta", bold=True)), end="\r")
+                self._idx += 1
+                time.sleep(DivineOpsBlueprint.Spinner.INTERVAL)
+            self.console.print(" " * 40, end="\r")
+        def stop(self, final="🌟 All pantheon tasks complete!"):
+            self._stop.set()
+            self._thread.join()
+            self.console.print(Text(final, style=Style(color="green", bold=True)))
 
     """ Divine Ops: Streamlined Software Dev & Sysadmin Team Blueprint using openai-agents """
     metadata: ClassVar[Dict[str, Any]] = {
@@ -282,11 +409,16 @@ class DivineOpsBlueprint(BlueprintBase):
         return zeus_agent
 
     async def run(self, messages: List[Dict[str, Any]], **kwargs) -> Any:
-        """Main execution entry point for the DivineOps blueprint."""
+        """Main execution entry point for the DivineOps blueprint with ANSI spinner."""
         logger.info("DivineOpsBlueprint run method called.")
+        # Start spinner
+        self._spinner = DivineOpsSpinner()
+        self._spinner.start()
         instruction = messages[-1].get("content", "") if messages else ""
         async for chunk in self._run_non_interactive(instruction, **kwargs):
             yield chunk
+        # Stop spinner and show completion
+        self._spinner.stop()
         logger.info("DivineOpsBlueprint run method finished.")
 
     async def _run_non_interactive(self, instruction: str, **kwargs) -> Any:
@@ -302,6 +434,18 @@ class DivineOpsBlueprint(BlueprintBase):
             logger.error(f"Error during non-interactive run: {e}", exc_info=True)
             yield { "messages": [ {"role": "assistant", "content": f"An error occurred: {e}"} ] }
 
+class ZeusBlueprint(BlueprintBase):
+    def __init__(self, blueprint_id: str = "zeus", config=None, config_path=None, **kwargs):
+        super().__init__()
+        self.blueprint_id = blueprint_id
+        self.config_path = config_path
+        self._config = config if config is not None else None
+        self._llm_profile_name = None
+        self._llm_profile_data = None
+        self._markdown_output = None
+        # Add other attributes as needed for Zeus
+        # ...
+
 # Standard Python entry point
 if __name__ == "__main__":
     import asyncio
@@ -312,6 +456,35 @@ if __name__ == "__main__":
     ]
     blueprint = DivineOpsBlueprint(blueprint_id="demo-1")
     async def run_and_print():
-        async for response in blueprint.run(messages):
-            print(json.dumps(response, indent=2))
+        spinner = DivineOpsSpinner()
+        spinner.start()
+        try:
+            all_results = []
+            async for response in blueprint.run(messages):
+                content = response["messages"][0]["content"] if (isinstance(response, dict) and "messages" in response and response["messages"]) else str(response)
+                all_results.append(content)
+                # Enhanced progressive output
+                if isinstance(response, dict) and (response.get("progress") or response.get("matches")):
+                    display_operation_box(
+                        title="Progressive Operation",
+                        content="\n".join(response.get("matches", [])),
+                        style="bold cyan" if response.get("type") == "code_search" else "bold magenta",
+                        result_count=len(response.get("matches", [])) if response.get("matches") is not None else None,
+                        params={k: v for k, v in response.items() if k not in {'matches', 'progress', 'total', 'truncated', 'done'}},
+                        progress_line=response.get('progress'),
+                        total_lines=response.get('total'),
+                        spinner_state=spinner.current_spinner_state() if hasattr(spinner, 'current_spinner_state') else None,
+                        op_type=response.get("type", "search"),
+                        emoji="🔍" if response.get("type") == "code_search" else "🧠"
+                    )
+        finally:
+            spinner.stop()
+        display_operation_box(
+            title="Divine Output",
+            content="\n".join(all_results),
+            style="bold green",
+            result_count=len(all_results),
+            params={"prompt": messages[0]["content"]},
+            op_type="divine"
+        )
     asyncio.run(run_and_print())

swarm/blueprints/django_chat/blueprint_django_chat.py

@@ -9,6 +9,9 @@ import logging
 import sys
 import os
 from typing import Dict, Any, List
+from swarm.blueprints.common.operation_box_utils import display_operation_box
+from swarm.core.blueprint_ux import BlueprintUXImproved
+import time
 
 # --- Logging Setup ---
 def setup_logging():
@@ -49,9 +52,78 @@ from swarm.utils.logger_setup import setup_logger
 
 logger = setup_logger(__name__)
 
+# --- Spinner and ANSI/emoji operation box for unified UX (for CLI/dev runs) ---
+from swarm.ux.ansi_box import ansi_box
+from rich.console import Console
+from rich.style import Style
+from rich.text import Text
+import threading
+import time
+
+class DjangoChatSpinner:
+    FRAMES = [
+        "Generating.", "Generating..", "Generating...", "Running...",
+        "⠋ Generating...", "⠙ Generating...", "⠹ Generating...", "⠸ Generating...",
+        "⠼ Generating...", "⠴ Generating...", "⠦ Generating...", "⠧ Generating...",
+        "⠇ Generating...", "⠏ Generating...", "🤖 Generating...", "💡 Generating...", "✨ Generating..."
+    ]
+    SLOW_FRAME = "Generating... Taking longer than expected"
+    INTERVAL = 0.12
+    SLOW_THRESHOLD = 10  # seconds
+
+    def __init__(self):
+        self._stop_event = threading.Event()
+        self._thread = None
+        self._start_time = None
+        self.console = Console()
+        self._last_frame = None
+        self._last_slow = False
+
+    def start(self):
+        self._stop_event.clear()
+        self._start_time = time.time()
+        self._thread = threading.Thread(target=self._spin, daemon=True)
+        self._thread.start()
+
+    def _spin(self):
+        idx = 0
+        while not self._stop_event.is_set():
+            elapsed = time.time() - self._start_time
+            if elapsed > self.SLOW_THRESHOLD:
+                txt = Text(self.SLOW_FRAME, style=Style(color="yellow", bold=True))
+                self._last_frame = self.SLOW_FRAME
+                self._last_slow = True
+            else:
+                frame = self.FRAMES[idx % len(self.FRAMES)]
+                txt = Text(frame, style=Style(color="cyan", bold=True))
+                self._last_frame = frame
+                self._last_slow = False
+            self.console.print(txt, end="\r", soft_wrap=True, highlight=False)
+            time.sleep(self.INTERVAL)
+            idx += 1
+        self.console.print(" " * 40, end="\r")  # Clear line
+
+    def stop(self, final_message="Done!"):
+        self._stop_event.set()
+        if self._thread:
+            self._thread.join()
+        self.console.print(Text(final_message, style=Style(color="green", bold=True)))
+
+    def current_spinner_state(self):
+        if self._last_slow:
+            return self.SLOW_FRAME
+        return self._last_frame or self.FRAMES[0]
+
+
 class DjangoChatBlueprint(Blueprint):
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
+    def __init__(self, blueprint_id: str = "django_chat", config=None, config_path=None, **kwargs):
+        super().__init__(blueprint_id, config=config, config_path=config_path, **kwargs)
+        self.blueprint_id = blueprint_id
+        self.config_path = config_path
+        self._config = config if config is not None else None
+        self._llm_profile_name = None
+        self._llm_profile_data = None
+        self._markdown_output = None
         class DummyLLM:
             def chat_completion_stream(self, messages, **_):
                 class DummyStream:
@@ -100,26 +172,51 @@ class DjangoChatBlueprint(Blueprint):
     def render_prompt(self, template_name: str, context: dict) -> str:
         return f"User request: {context.get('user_request', '')}\nHistory: {context.get('history', '')}\nAvailable tools: {', '.join(context.get('available_tools', []))}"
 
-    async def run(self, messages: List[Dict[str, str]]) -> object:
-        last_user_message = next((m['content'] for m in reversed(messages) if m['role'] == 'user'), None)
-        if not last_user_message:
-            yield {"messages": [{"role": "assistant", "content": "I need a user message to proceed."}]}
-            return
-        prompt_context = {
-            "user_request": last_user_message,
-            "history": messages[:-1],
-            "available_tools": ["django_chat"]
-        }
-        rendered_prompt = self.render_prompt("django_chat_prompt.j2", prompt_context)
-        yield {
-            "messages": [
-                {
-                    "role": "assistant",
-                    "content": f"[DjangoChat LLM] Would respond to: {rendered_prompt}"
-                }
-            ]
-        }
-        return
+    async def run(self, messages: List[Dict[str, str]]):
+        """Main execution entry point for the DjangoChat blueprint."""
+        logger.info("DjangoChatBlueprint run method called.")
+        instruction = messages[-1].get("content", "") if messages else ""
+        ux = BlueprintUXImproved(style="serious")
+        spinner_idx = 0
+        start_time = time.time()
+        spinner_yield_interval = 1.0  # seconds
+        last_spinner_time = start_time
+        yielded_spinner = False
+        result_chunks = []
+        try:
+            # Simulate agent runner pattern (replace with actual agent logic if available)
+            prompt_context = {
+                "user_request": instruction,
+                "history": messages[:-1],
+                "available_tools": ["django_chat"]
+            }
+            rendered_prompt = self.render_prompt("django_chat_prompt.j2", prompt_context)
+            # Simulate progressive spinner for a few cycles
+            for _ in range(3):
+                now = time.time()
+                if now - last_spinner_time >= spinner_yield_interval:
+                    taking_long = (now - start_time > 10)
+                    spinner_msg = ux.spinner(spinner_idx, taking_long=taking_long)
+                    yield {"messages": [{"role": "assistant", "content": spinner_msg}]}
+                    spinner_idx += 1
+                    last_spinner_time = now
+                    yielded_spinner = True
+                    await asyncio.sleep(0.2)
+            # Final result
+            summary = ux.summary("Operation", 1, {"instruction": instruction[:40]})
+            box = ux.ansi_emoji_box(
+                title="DjangoChat Result",
+                content=f"[DjangoChat LLM] Would respond to: {rendered_prompt}",
+                summary=summary,
+                params={"instruction": instruction[:40]},
+                result_count=1,
+                op_type="run",
+                status="success"
+            )
+            yield {"messages": [{"role": "assistant", "content": box}]}
+        except Exception as e:
+            logger.error(f"Error during DjangoChat run: {e}", exc_info=True)
+            yield {"messages": [{"role": "assistant", "content": f"An error occurred: {e}"}]}
 
     def run_with_context(self, messages: List[Dict[str, str]], context_variables: dict) -> dict:
         """Minimal implementation for CLI compatibility without agents."""
@@ -137,6 +234,35 @@ if __name__ == "__main__":
     ]
     blueprint = DjangoChatBlueprint(blueprint_id="demo-1")
     async def run_and_print():
-        async for response in blueprint.run(messages):
-            print(json.dumps(response, indent=2))
+        spinner = DjangoChatSpinner()
+        spinner.start()
+        try:
+            all_results = []
+            async for response in blueprint.run(messages):
+                content = response["messages"][0]["content"] if (isinstance(response, dict) and "messages" in response and response["messages"]) else str(response)
+                all_results.append(content)
+                # Enhanced progressive output
+                if isinstance(response, dict) and (response.get("progress") or response.get("matches")):
+                    display_operation_box(
+                        title="Progressive Operation",
+                        content="\n".join(response.get("matches", [])),
+                        style="bold cyan" if response.get("type") == "code_search" else "bold magenta",
+                        result_count=len(response.get("matches", [])) if response.get("matches") is not None else None,
+                        params={k: v for k, v in response.items() if k not in {'matches', 'progress', 'total', 'truncated', 'done'}},
+                        progress_line=response.get('progress'),
+                        total_lines=response.get('total'),
+                        spinner_state=spinner.current_spinner_state() if hasattr(spinner, 'current_spinner_state') else None,
+                        op_type=response.get("type", "search"),
+                        emoji="🔍" if response.get("type") == "code_search" else "🧠"
+                    )
+        finally:
+            spinner.stop()
+        display_operation_box(
+            title="DjangoChat Output",
+            content="\n".join(all_results),
+            style="bold green",
+            result_count=len(all_results),
+            params={"prompt": messages[0]["content"]},
+            op_type="django_chat"
+        )
     asyncio.run(run_and_print())

swarm/blueprints/echocraft/blueprint_echocraft.py

@@ -36,12 +36,28 @@ def list_files(directory: str = '.') -> str:
     except Exception as e:
         return f"ERROR: {e}"
 def execute_shell_command(command: str) -> str:
-    import subprocess
+    """
+    Executes a shell command and returns its stdout and stderr.
+    Timeout is configurable via SWARM_COMMAND_TIMEOUT (default: 60s).
+    """
+    logger.info(f"Executing shell command: {command}")
     try:
-        result = subprocess.run(command, shell=True, capture_output=True, text=True)
-        return result.stdout + result.stderr
+        import os
+        timeout = int(os.getenv("SWARM_COMMAND_TIMEOUT", "60"))
+        result = subprocess.run(command, shell=True, capture_output=True, text=True, timeout=timeout)
+        output = f"Exit Code: {result.returncode}\n"
+        if result.stdout:
+            output += f"STDOUT:\n{result.stdout}\n"
+        if result.stderr:
+            output += f"STDERR:\n{result.stderr}\n"
+        logger.info(f"Command finished. Exit Code: {result.returncode}")
+        return output.strip()
+    except subprocess.TimeoutExpired:
+        logger.error(f"Command timed out: {command}")
+        return f"Error: Command timed out after {os.getenv('SWARM_COMMAND_TIMEOUT', '60')} seconds."
     except Exception as e:
-        return f"ERROR: {e}"
+        logger.error(f"Error executing command '{command}': {e}", exc_info=True)
+        return f"Error executing command: {e}"
 read_file_tool = PatchedFunctionTool(read_file, 'read_file')
 write_file_tool = PatchedFunctionTool(write_file, 'write_file')
 list_files_tool = PatchedFunctionTool(list_files, 'list_files')
@@ -67,8 +83,16 @@ Self-healing, fileops-enabled, swarm-scalable.
 # rue_code error handling: try/except ImportError with sys.exit(1)
 
 class EchoCraftBlueprint(BlueprintBase):
-    def __init__(self, blueprint_id: str, config_path: Optional[Path] = None, **kwargs):
-        super().__init__(blueprint_id, config_path=config_path, **kwargs)
+    def __init__(self, blueprint_id: str = "echocraft", config=None, config_path=None, **kwargs):
+        super().__init__(blueprint_id, config=config, config_path=config_path, **kwargs)
+        self.blueprint_id = blueprint_id
+        self.config_path = config_path
+        self._config = config if config is not None else {}
+        self._llm_profile_name = None
+        self._llm_profile_data = None
+        self._markdown_output = None
+        # Add other attributes as needed for Echocraft
+        # ...
 
     """
     A simple blueprint that echoes the last user message.
@@ -99,13 +123,29 @@ class EchoCraftBlueprint(BlueprintBase):
             return '\n'.join(os.listdir(directory))
         except Exception as e:
             return f"ERROR: {e}"
-    def execute_shell_command(command: str) -> str:
-        import subprocess
+    def execute_shell_command(self, command: str) -> str:
+        """
+        Executes a shell command and returns its stdout and stderr.
+        Timeout is configurable via SWARM_COMMAND_TIMEOUT (default: 60s).
+        """
+        logger.info(f"Executing shell command: {command}")
         try:
-            result = subprocess.run(command, shell=True, capture_output=True, text=True)
-            return result.stdout + result.stderr
+            import os
+            timeout = int(os.getenv("SWARM_COMMAND_TIMEOUT", "60"))
+            result = subprocess.run(command, shell=True, capture_output=True, text=True, timeout=timeout)
+            output = f"Exit Code: {result.returncode}\n"
+            if result.stdout:
+                output += f"STDOUT:\n{result.stdout}\n"
+            if result.stderr:
+                output += f"STDERR:\n{result.stderr}\n"
+            logger.info(f"Command finished. Exit Code: {result.returncode}")
+            return output.strip()
+        except subprocess.TimeoutExpired:
+            logger.error(f"Command timed out: {command}")
+            return f"Error: Command timed out after {os.getenv('SWARM_COMMAND_TIMEOUT', '60')} seconds."
         except Exception as e:
-            return f"ERROR: {e}"
+            logger.error(f"Error executing command '{command}': {e}", exc_info=True)
+            return f"Error executing command: {e}"
     read_file_tool = PatchedFunctionTool(read_file, 'read_file')
     write_file_tool = PatchedFunctionTool(write_file, 'write_file')
     list_files_tool = PatchedFunctionTool(list_files, 'list_files')
@@ -241,6 +281,82 @@ class EchoCraftBlueprint(BlueprintBase):
         )
         return echo_agent
 
+# --- Spinner and ANSI/emoji operation box for unified UX (for CLI/dev runs) ---
+from swarm.ux.ansi_box import ansi_box
+from rich.console import Console
+from rich.style import Style
+from rich.text import Text
+import threading
+import time
+
+class EchoCraftSpinner:
+    FRAMES = [
+        "Generating.", "Generating..", "Generating...", "Running...",
+        "⠋ Generating...", "⠙ Generating...", "⠹ Generating...", "⠸ Generating...",
+        "⠼ Generating...", "⠴ Generating...", "⠦ Generating...", "⠧ Generating...",
+        "⠇ Generating...", "⠏ Generating...", "🤖 Generating...", "💡 Generating...", "✨ Generating..."
+    ]
+    SLOW_FRAME = "Generating... Taking longer than expected"
+    INTERVAL = 0.12
+    SLOW_THRESHOLD = 10  # seconds
+
+    def __init__(self):
+        self._stop_event = threading.Event()
+        self._thread = None
+        self._start_time = None
+        self.console = Console()
+        self._last_frame = None
+        self._last_slow = False
+
+    def start(self):
+        self._stop_event.clear()
+        self._start_time = time.time()
+        self._thread = threading.Thread(target=self._spin, daemon=True)
+        self._thread.start()
+
+    def _spin(self):
+        idx = 0
+        while not self._stop_event.is_set():
+            elapsed = time.time() - self._start_time
+            if elapsed > self.SLOW_THRESHOLD:
+                txt = Text(self.SLOW_FRAME, style=Style(color="yellow", bold=True))
+                self._last_frame = self.SLOW_FRAME
+                self._last_slow = True
+            else:
+                frame = self.FRAMES[idx % len(self.FRAMES)]
+                txt = Text(frame, style=Style(color="cyan", bold=True))
+                self._last_frame = frame
+                self._last_slow = False
+            self.console.print(txt, end="\r", soft_wrap=True, highlight=False)
+            time.sleep(self.INTERVAL)
+            idx += 1
+        self.console.print(" " * 40, end="\r")  # Clear line
+
+    def stop(self, final_message="Done!"):
+        self._stop_event.set()
+        if self._thread:
+            self._thread.join()
+        self.console.print(Text(final_message, style=Style(color="green", bold=True)))
+
+    def current_spinner_state(self):
+        if self._last_slow:
+            return self.SLOW_FRAME
+        return self._last_frame or self.FRAMES[0]
+
+
+def print_operation_box(op_type, results, params=None, result_type="echo", taking_long=False):
+    emoji = "🗣️" if result_type == "echo" else "🔍"
+    style = 'success' if result_type == "echo" else 'default'
+    box_title = op_type if op_type else ("EchoCraft Output" if result_type == "echo" else "Results")
+    summary_lines = []
+    count = len(results) if isinstance(results, list) else 0
+    summary_lines.append(f"Results: {count}")
+    if params:
+        for k, v in params.items():
+            summary_lines.append(f"{k.capitalize()}: {v}")
+    box_content = "\n".join(summary_lines + ["\n".join(map(str, results))])
+    ansi_box(box_title, box_content, count=count, params=params, style=style if not taking_long else 'warning', emoji=emoji)
+
 if __name__ == "__main__":
     import asyncio
     import json
@@ -250,6 +366,19 @@ if __name__ == "__main__":
     ]
     blueprint = EchoCraftBlueprint(blueprint_id="demo-1")
     async def run_and_print():
-        async for response in blueprint.run(messages):
-            print(json.dumps(response, indent=2))
+        spinner = EchoCraftSpinner()
+        spinner.start()
+        try:
+            all_results = []
+            async for response in blueprint.run(messages):
+                content = response["messages"][0]["content"]
+                all_results.append(content)
+        finally:
+            spinner.stop()
+        print_operation_box(
+            op_type="EchoCraft Output",
+            results=all_results,
+            params={"prompt": messages[0]["content"]},
+            result_type="echo"
+        )
     asyncio.run(run_and_print())