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

swarm/blueprints/monkai_magic/blueprint_monkai_magic.py

@@ -1,340 +0,0 @@
-"""
-MonkaiMagic: Cloud Operations Journey Blueprint
-
-A *Monkai Magic*-inspired crew managing AWS, Fly.io, and Vercel with pre-authenticated CLIs:
-- Tripitaka (Wise Leader/Coordinator)
-- Monkey (Cloud Trickster/AWS Master)
-- Pigsy (Greedy Tinker/CLI Handler)
-- Sandy (River Sage/Ops Watcher)
-
-Uses BlueprintBase, @function_tool for direct CLI calls, and agent-as-tool delegation.
-Assumes pre-authenticated aws, flyctl, and vercel commands.
-"""
-
-import os
-import logging
-import subprocess
-import sys
-import shlex # Import shlex
-from typing import Dict, Any, List, ClassVar, Optional
-import time
-from swarm.core.blueprint_ux import BlueprintUXImproved
-
-# Ensure src is in path for BlueprintBase import
-project_root = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..'))
-src_path = os.path.join(project_root, 'src')
-if src_path not in sys.path: sys.path.insert(0, src_path)
-
-try:
-    from agents import Agent, Tool, function_tool, Runner
-    from agents.mcp import MCPServer
-    from agents.models.interface import Model
-    from agents.models.openai_chatcompletions import OpenAIChatCompletionsModel
-    from openai import AsyncOpenAI
-    from swarm.core.blueprint_base import BlueprintBase
-except ImportError as e:
-    print(f"ERROR: Import failed in MonkaiMagicBlueprint: {e}. Check dependencies.")
-    print(f"sys.path: {sys.path}")
-    sys.exit(1)
-
-logger = logging.getLogger(__name__)
-
-# --- Cloud CLI Function Tools ---
-@function_tool
-def aws_cli(command: str) -> str:
-    """Executes an AWS CLI command (e.g., 's3 ls', 'ec2 describe-instances'). Assumes pre-authentication. Timeout is configurable via SWARM_COMMAND_TIMEOUT (default: 120s)."""
-    if not command: return "Error: No AWS command provided."
-    try:
-        import os
-        timeout = int(os.getenv("SWARM_COMMAND_TIMEOUT", "120"))
-        cmd_parts = ["aws"] + shlex.split(command)
-        logger.info(f"Executing AWS CLI: {' '.join(cmd_parts)}")
-        result = subprocess.run(cmd_parts, check=True, capture_output=True, text=True, timeout=timeout)
-        output = result.stdout.strip()
-        logger.debug(f"AWS CLI success. Output:\n{output[:500]}...")
-        return f"OK: AWS command successful.\nOutput:\n{output}"
-    except FileNotFoundError:
-        logger.error("AWS CLI ('aws') command not found. Is it installed and in PATH?")
-        return "Error: AWS CLI command not found."
-    except subprocess.CalledProcessError as e:
-        error_output = e.stderr.strip() or e.stdout.strip()
-        logger.error(f"AWS CLI error executing '{command}': {error_output}")
-        return f"Error executing AWS command '{command}': {error_output}"
-    except subprocess.TimeoutExpired:
-        logger.error(f"AWS CLI command '{command}' timed out.")
-        return f"Error: AWS CLI command '{command}' timed out after {os.getenv('SWARM_COMMAND_TIMEOUT', '120')} seconds."
-    except Exception as e:
-        logger.error(f"Unexpected error during AWS CLI execution: {e}", exc_info=logger.level <= logging.DEBUG)
-        return f"Error: Unexpected error during AWS CLI: {e}"
-
-@function_tool
-def fly_cli(command: str) -> str:
-    """Executes a Fly.io CLI command ('flyctl ...'). Assumes pre-authentication ('flyctl auth login'). Timeout is configurable via SWARM_COMMAND_TIMEOUT (default: 120s)."""
-    if not command: return "Error: No Fly command provided."
-    try:
-        import os
-        timeout = int(os.getenv("SWARM_COMMAND_TIMEOUT", "120"))
-        cmd_parts = ["flyctl"] + shlex.split(command)
-        logger.info(f"Executing Fly CLI: {' '.join(cmd_parts)}")
-        result = subprocess.run(cmd_parts, check=True, capture_output=True, text=True, timeout=timeout)
-        output = result.stdout.strip()
-        logger.debug(f"Fly CLI success. Output:\n{output[:500]}...")
-        return f"OK: Fly command successful.\nOutput:\n{output}"
-    except FileNotFoundError:
-        logger.error("Fly CLI ('flyctl') command not found. Is it installed and in PATH?")
-        return "Error: Fly CLI command not found."
-    except subprocess.CalledProcessError as e:
-        error_output = e.stderr.strip() or e.stdout.strip()
-        logger.error(f"Fly CLI error executing '{command}': {error_output}")
-        return f"Error executing Fly command '{command}': {error_output}"
-    except subprocess.TimeoutExpired:
-        logger.error(f"Fly CLI command '{command}' timed out.")
-        return f"Error: Fly CLI command '{command}' timed out after {os.getenv('SWARM_COMMAND_TIMEOUT', '120')} seconds."
-    except Exception as e:
-        logger.error(f"Unexpected error during Fly CLI execution: {e}", exc_info=logger.level <= logging.DEBUG)
-        return f"Error: Unexpected error during Fly CLI: {e}"
-
-@function_tool
-def vercel_cli(command: str) -> str:
-    """Executes a Vercel CLI command ('vercel ...'). Assumes pre-authentication ('vercel login'). Timeout is configurable via SWARM_COMMAND_TIMEOUT (default: 120s)."""
-    if not command: return "Error: No Vercel command provided."
-    try:
-        import os
-        timeout = int(os.getenv("SWARM_COMMAND_TIMEOUT", "120"))
-        cmd_parts = ["vercel"] + shlex.split(command)
-        logger.info(f"Executing Vercel CLI: {' '.join(cmd_parts)}")
-        result = subprocess.run(cmd_parts, check=True, capture_output=True, text=True, timeout=timeout)
-        output = result.stdout.strip()
-        logger.debug(f"Vercel CLI success. Output:\n{output[:500]}...")
-        return f"OK: Vercel command successful.\nOutput:\n{output}"
-    except FileNotFoundError:
-        logger.error("Vercel CLI ('vercel') command not found. Is it installed and in PATH?")
-        return "Error: Vercel CLI command not found."
-    except subprocess.CalledProcessError as e:
-        error_output = e.stderr.strip() or e.stdout.strip()
-        logger.error(f"Vercel CLI error executing '{command}': {error_output}")
-        return f"Error executing Vercel command '{command}': {error_output}"
-    except subprocess.TimeoutExpired:
-        logger.error(f"Vercel CLI command '{command}' timed out.")
-        return f"Error: Vercel CLI command '{command}' timed out after {os.getenv('SWARM_COMMAND_TIMEOUT', '120')} seconds."
-    except Exception as e:
-        logger.error(f"Unexpected error during Vercel CLI execution: {e}", exc_info=logger.level <= logging.DEBUG)
-        return f"Error: Unexpected error during Vercel CLI: {e}"
-
-
-# --- Define the Blueprint ---
-# === OpenAI GPT-4.1 Prompt Engineering Guide ===
-# See: https://github.com/openai/openai-cookbook/blob/main/examples/gpt4-1_prompting_guide.ipynb
-#
-# Agentic System Prompt Example (recommended for cloud ops agents):
-SYS_PROMPT_AGENTIC = """
-You are an agent - please keep going until the user’s query is completely resolved, before ending your turn and yielding back to the user. Only terminate your turn when you are sure that the problem is solved.
-If you are not sure about file content or codebase structure pertaining to the user’s request, use your tools to read files and gather the relevant information: do NOT guess or make up an answer.
-You MUST plan extensively before each function call, and reflect extensively on the outcomes of the previous function calls. DO NOT do this entire process by making function calls only, as this can impair your ability to solve the problem and think insightfully.
-"""
-
-class MonkaiMagicBlueprint(BlueprintBase):
-    """Blueprint for a cloud operations team inspired by *Monkai Magic*."""
-    metadata: ClassVar[Dict[str, Any]] = {
-        "name": "MonkaiMagicBlueprint",
-        "title": "MonkaiMagic: Cloud Operations Journey",
-        "description": "A *Monkai Magic*-inspired crew managing AWS, Fly.io, and Vercel with pre-authenticated CLI tools and agent-as-tool delegation.",
-        "version": "1.1.0", # Refactored version
-        "author": "Open Swarm Team (Refactored)",
-        "tags": ["cloud", "aws", "fly.io", "vercel", "cli", "multi-agent"],
-        "required_mcp_servers": ["mcp-shell"], # Only Sandy needs an MCP server
-        "env_vars": ["AWS_REGION", "FLY_REGION", "VERCEL_ORG_ID"] # Optional vars for instruction hints
-    }
-
-    def __init__(self, blueprint_id: str = "monkai_magic", config=None, config_path=None, **kwargs):
-        super().__init__(blueprint_id=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
-        # Add other attributes as needed for MonkaiMagic
-        # ...
-
-    # Caches
-    _openai_client_cache: Dict[str, AsyncOpenAI] = {}
-    _model_instance_cache: Dict[str, Model] = {}
-
-    # --- Model Instantiation Helper --- (Standard helper)
-    def _get_model_instance(self, profile_name: str) -> Model:
-        """Retrieves or creates an LLM Model instance."""
-        # ... (Implementation is the same as previous refactors) ...
-        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)
-        if not profile_data: raise ValueError(f"Missing LLM profile '{profile_name}'.")
-        provider = profile_data.get("provider", "openai").lower()
-        model_name = profile_data.get("model")
-        if not model_name: raise ValueError(f"Missing 'model' in profile '{profile_name}'.")
-        if provider != "openai": raise ValueError(f"Unsupported provider: {provider}")
-        client_cache_key = f"{provider}_{profile_data.get('base_url')}"
-        if client_cache_key not in self._openai_client_cache:
-             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}': {log_kwargs}")
-             try: self._openai_client_cache[client_cache_key] = AsyncOpenAI(**filtered_kwargs)
-             except Exception as e: raise ValueError(f"Failed to init client: {e}") from e
-        client = self._openai_client_cache[client_cache_key]
-        logger.debug(f"Instantiating OpenAIChatCompletionsModel(model='{model_name}') for '{profile_name}'.")
-        try:
-            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
-
-    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, **kwargs):
-        """Main execution entry point for the MonkaiMagic blueprint."""
-        logger.info("MonkaiMagicBlueprint run method called.")
-        instruction = messages[-1].get("content", "") if messages else ""
-        from agents import Runner
-        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:
-            runner_gen = Runner.run(self.create_starting_agent([]), instruction)
-            while True:
-                now = time.time()
-                try:
-                    chunk = next(runner_gen)
-                    result_chunks.append(chunk)
-                    # If chunk is a final result, wrap and yield
-                    if chunk and isinstance(chunk, dict) and "messages" in chunk:
-                        content = chunk["messages"][0]["content"] if chunk["messages"] else ""
-                        summary = ux.summary("Operation", len(result_chunks), {"instruction": instruction[:40]})
-                        box = ux.ansi_emoji_box(
-                            title="MonkaiMagic Result",
-                            content=content,
-                            summary=summary,
-                            params={"instruction": instruction[:40]},
-                            result_count=len(result_chunks),
-                            op_type="run",
-                            status="success"
-                        )
-                        yield {"messages": [{"role": "assistant", "content": box}]}
-                    else:
-                        yield chunk
-                    yielded_spinner = False
-                except StopIteration:
-                    break
-                except Exception:
-                    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
-            if not result_chunks and not yielded_spinner:
-                yield {"messages": [{"role": "assistant", "content": ux.spinner(0)}]}
-        except Exception as e:
-            logger.error(f"Error during MonkaiMagic run: {e}", exc_info=True)
-            yield {"messages": [{"role": "assistant", "content": f"An error occurred: {e}"}]}
-
-    def create_starting_agent(self, mcp_servers: List[MCPServer]) -> Agent:
-        """Creates the MonkaiMagic agent team and returns Tripitaka."""
-        logger.debug("Creating MonkaiMagic agent team...")
-        self._model_instance_cache = {}
-        self._openai_client_cache = {}
-
-        default_profile_name = self.config.get("llm_profile", "default")
-        logger.debug(f"Using LLM profile '{default_profile_name}' for MonkaiMagic agents.")
-        model_instance = self._get_model_instance(default_profile_name)
-
-        # Get optional env var hints
-        aws_region = os.getenv("AWS_REGION")
-        fly_region = os.getenv("FLY_REGION")
-        vercel_org_id = os.getenv("VERCEL_ORG_ID")
-
-        # --- Define Agent Instructions (with optional hints) ---
-        tripitaka_instructions = (
-            "You are Tripitaka, the wise leader guiding the cloud journey:\n"
-            "- Lead with calm wisdom, analyzing user requests for cloud operations.\n"
-            "- Delegate tasks to the appropriate specialist agent using their Agent Tool:\n"
-            "  - `Monkey`: For AWS related tasks (use the `aws_cli` function tool).\n"
-            "  - `Pigsy`: For Fly.io or Vercel tasks (use `fly_cli` or `vercel_cli` function tools).\n"
-            "  - `Sandy`: For monitoring or diagnostic shell commands related to deployments.\n"
-            "- Synthesize the results from your team into a final response for the user. You do not track state yourself."
-        )
-
-        monkey_instructions = (
-            "You are Monkey, the cloud trickster and AWS master:\n"
-            "- Execute AWS tasks requested by Tripitaka using the `aws_cli` function tool.\n"
-            "- Assume the `aws` command is pre-authenticated.\n"
-            f"- {f'Default AWS region seems to be {aws_region}. Use this unless specified otherwise.' if aws_region else 'No default AWS region hint available.'}\n"
-            "- Report the results (success or error) clearly back to Tripitaka."
-        )
-
-        pigsy_instructions = (
-            "You are Pigsy, the greedy tinker handling Fly.io and Vercel CLI hosting:\n"
-            "- Execute Fly.io tasks using the `fly_cli` function tool.\n"
-            "- Execute Vercel tasks using the `vercel_cli` function tool.\n"
-            "- Assume `flyctl` and `vercel` commands are pre-authenticated.\n"
-            f"- {f'Default Fly.io region hint: {fly_region}.' if fly_region else 'No default Fly.io region hint.'}\n"
-            f"- {f'Default Vercel Org ID hint: {vercel_org_id}.' if vercel_org_id else 'No default Vercel Org ID hint.'}\n"
-            "- Report the results clearly back to Tripitaka."
-        )
-
-        sandy_instructions = (
-            "You are Sandy, the river sage and ops watcher:\n"
-            "- Execute general shell commands requested by Tripitaka for monitoring or diagnostics using the `mcp-shell` MCP tool.\n"
-            "- Report the output or status steadily back to Tripitaka.\n"
-            "Available MCP Tools: mcp-shell."
-        )
-
-        # Instantiate agents
-        monkey_agent = Agent(
-            name="Monkey", model=model_instance, instructions=monkey_instructions,
-            tools=[aws_cli], # Function tool for AWS
-            mcp_servers=[]
-        )
-        pigsy_agent = Agent(
-            name="Pigsy", model=model_instance, instructions=pigsy_instructions,
-            tools=[fly_cli, vercel_cli], # Function tools for Fly/Vercel
-            mcp_servers=[]
-        )
-        sandy_agent = Agent(
-            name="Sandy", model=model_instance, instructions=sandy_instructions,
-            tools=[], # Uses MCP only
-            mcp_servers=[s for s in mcp_servers if s.name == 'mcp-shell'] # Pass only relevant MCP
-        )
-        tripitaka_agent = Agent(
-            name="Tripitaka", model=model_instance, instructions=tripitaka_instructions,
-            tools=[ # Delegate via Agent-as-Tool
-                monkey_agent.as_tool(tool_name="Monkey", tool_description="Delegate AWS tasks to Monkey."),
-                pigsy_agent.as_tool(tool_name="Pigsy", tool_description="Delegate Fly.io or Vercel tasks to Pigsy."),
-                sandy_agent.as_tool(tool_name="Sandy", tool_description="Delegate monitoring or diagnostic shell commands to Sandy.")
-            ],
-            mcp_servers=[]
-        )
-
-        logger.debug("MonkaiMagic Team created. Starting with Tripitaka.")
-        return tripitaka_agent
-
-# Standard Python entry point
-if __name__ == "__main__":
-    import asyncio
-    import json
-    messages = [
-        {"role": "user", "content": "Do some magic."}
-    ]
-    blueprint = MonkaiMagicBlueprint(blueprint_id="demo-1")
-    async def run_and_print():
-        async for response in blueprint.run(messages):
-            print(json.dumps(response, indent=2))
-    asyncio.run(run_and_print())

swarm/blueprints/nebula_shellz/blueprint_nebula_shellz.py

@@ -1,265 +0,0 @@
-import logging
-import os
-import sys
-import asyncio
-import subprocess
-import re
-import inspect
-from typing import Dict, Any, List, Optional, ClassVar
-
-try:
-    from agents import Agent, Tool, function_tool
-    from agents.mcp import MCPServer
-    from agents.models.interface import Model
-    from agents.models.openai_chatcompletions import OpenAIChatCompletionsModel
-    from openai import AsyncOpenAI
-    from swarm.core.blueprint_base import BlueprintBase
-    from rich.panel import Panel # Import Panel for splash screen
-    from swarm.core.blueprint_ux import BlueprintUXImproved
-    import time
-except ImportError as e:
-    print(f"ERROR: Import failed in nebula_shellz: {e}. Ensure 'openai-agents' install and structure.")
-    print(f"sys.path: {sys.path}")
-    sys.exit(1)
-
-logger = logging.getLogger(__name__)
-
-# --- Tool Definitions (Unchanged) ---
-@function_tool
-async def code_review(code_snippet: str) -> str:
-    """Performs a review of the provided code snippet."""
-    logger.info(f"Reviewing code snippet: {code_snippet[:50]}...")
-    await asyncio.sleep(0.1); issues = []; ("TODO" in code_snippet and issues.append("Found TODO.")); (len(code_snippet.splitlines()) > 100 and issues.append("Code long.")); return "Review: " + " ".join(issues) if issues else "Code looks good!"
-@function_tool
-def generate_documentation(code_snippet: str) -> str:
-    """Generates basic documentation string for the provided code snippet."""
-    logger.info(f"Generating documentation for: {code_snippet[:50]}...")
-    first_line = code_snippet.splitlines()[0] if code_snippet else "N/A"; doc = f"/**\n * This code snippet starts with: {first_line}...\n * TODO: Add more detailed documentation.\n */"; logger.debug(f"Generated documentation:\n{doc}"); return doc
-@function_tool
-def execute_shell_command(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}")
-    if not command:
-        logger.warning("execute_shell_command called with empty command.")
-        return "Error: No command provided."
-    try:
-        import os
-        timeout = int(os.getenv("SWARM_COMMAND_TIMEOUT", "60"))
-        result = subprocess.run(command, capture_output=True, text=True, timeout=timeout, check=False, shell=True)
-        output = f"Exit Code: {result.returncode}\nSTDOUT:\n{result.stdout.strip()}\nSTDERR:\n{result.stderr.strip()}"
-        logger.debug(f"Command '{command}' result:\n{output}")
-        return output
-    except FileNotFoundError:
-        cmd_base = command.split()[0] if command else ""
-        logger.error(f"Command not found: {cmd_base}")
-        return f"Error: Command not found - {cmd_base}"
-    except subprocess.TimeoutExpired:
-        logger.error(f"Command '{command}' timed out after configured timeout.")
-        return f"Error: Command '{command}' timed out after {os.getenv('SWARM_COMMAND_TIMEOUT', '60')} seconds."
-    except Exception as e:
-        logger.error(f"Error executing command '{command}': {e}", exc_info=logger.level <= logging.DEBUG)
-        return f"Error executing command: {e}"
-
-# --- Agent Definitions (Instructions remain the same) ---
-morpheus_instructions = """
-You are Morpheus, the leader... (Instructions as before) ...
-"""
-trinity_instructions = """
-You are Trinity, the investigator... (Instructions as before) ...
-"""
-neo_instructions = """
-You are Neo, the programmer... (Instructions as before) ...
-"""
-oracle_instructions = "You are the Oracle..."
-cypher_instructions = "You are Cypher..."
-tank_instructions = "You are Tank..."
-
-# --- Blueprint Definition ---
-from rich.console import Console
-from rich.panel import Panel
-from rich.live import Live
-from rich.text import Text
-import random
-import time
-
-class NebuchaShellzzarBlueprint(BlueprintBase):
-    """A multi-agent blueprint inspired by The Matrix for sysadmin and coding tasks."""
-    metadata: ClassVar[Dict[str, Any]] = {
-        "name": "NebulaShellzzarBlueprint", "title": "NebulaShellzzar",
-        "description": "A multi-agent blueprint inspired by The Matrix for system administration and coding tasks.",
-        "version": "1.0.0", "author": "Open Swarm Team",
-        "tags": ["matrix", "multi-agent", "shell", "coding", "mcp"],
-        "required_mcp_servers": ["memory"],
-    }
-    _model_instance_cache: Dict[str, Model] = {}
-
-    def __init__(self, blueprint_id: str = "nebula_shellzzar", config=None, config_path=None, **kwargs):
-        super().__init__(blueprint_id=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
-        # Add other attributes as needed for NebuchaShellzzar
-        # ...
-
-    # --- ADDED: Splash Screen ---
-    def display_splash_screen(self, animated: bool = False):
-        console = Console()
-        if not animated:
-            splash_text = """
-[bold green]Wake up, Neo...[/]
-[green]The Matrix has you...[/]
-[bold green]Follow the white rabbit.[/]
-
-Initializing NebulaShellzzar Crew...
-            """
-            panel = Panel(splash_text.strip(), title="[bold green]NebulaShellzzar[/]", border_style="green", expand=False)
-            console.print(panel)
-            console.print() # Add a blank line
-        else:
-            # Animated Matrix rain effect
-            width = 60
-            height = 12
-            charset = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789@#$%&"
-            rain_cols = [0] * width
-            with Live(refresh_per_second=20, console=console, transient=True) as live:
-                for _ in range(30):
-                    matrix = ""
-                    for y in range(height):
-                        line = ""
-                        for x in range(width):
-                            if random.random() < 0.02:
-                                rain_cols[x] = 0
-                            char = random.choice(charset) if rain_cols[x] < y else " "
-                            line += f"[green]{char}[/]"
-                        matrix += line + "\n"
-                    panel = Panel(Text.from_markup(matrix), title="[bold green]NebulaShellzzar[/]", border_style="green", expand=False)
-                    live.update(panel)
-                    time.sleep(0.07)
-            console.print("[bold green]Wake up, Neo...[/]")
-            console.print("[green]The Matrix has you...[/]")
-            console.print("[bold green]Follow the white rabbit.[/]")
-            console.print("\nInitializing NebulaShellzzar Crew...\n")
-
-    def _get_model_instance(self, profile_name: str) -> Model:
-        """Gets or creates a Model instance for the given profile name."""
-        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)
-        if not profile_data:
-             logger.critical(f"Cannot create Model instance: Profile '{profile_name}' (or default) not resolved.")
-             raise ValueError(f"Missing LLM profile configuration for '{profile_name}' or 'default'.")
-        provider = profile_data.get("provider", "openai").lower()
-        model_name = profile_data.get("model")
-        if not model_name:
-             logger.critical(f"LLM profile '{profile_name}' is missing the 'model' key.")
-             raise ValueError(f"Missing 'model' key in LLM profile '{profile_name}'.")
-
-        # Remove redundant client instantiation; rely on framework-level default client
-        # All blueprints now use the default client set at framework init
-        logger.debug(f"Instantiating OpenAIChatCompletionsModel(model='{model_name}') with default client.")
-        try: model_instance = OpenAIChatCompletionsModel(model=model_name)
-        except Exception as e:
-             logger.error(f"Failed to instantiate OpenAIChatCompletionsModel for profile '{profile_name}': {e}", exc_info=True)
-             raise ValueError(f"Failed to initialize LLM provider for profile '{profile_name}': {e}") from e
-        self._model_instance_cache[profile_name] = model_instance
-        return model_instance
-
-    def create_starting_agent(self, mcp_servers: List[MCPServer]) -> Agent:
-        """Creates the Matrix-themed agent team with Morpheus as the coordinator."""
-        logger.debug(f"Creating NebulaShellzzar agent team with {len(mcp_servers)} MCP server(s)...") # Changed to DEBUG
-        self._model_instance_cache = {}
-        default_profile_name = self.config.get("llm_profile", "default")
-        default_model_instance = self._get_model_instance(default_profile_name)
-        logger.debug(f"Using LLM profile '{default_profile_name}' for all agents.") # Changed to DEBUG
-
-        neo = Agent(name="Neo", model=default_model_instance, instructions=neo_instructions, tools=[code_review, generate_documentation, execute_shell_command], mcp_servers=mcp_servers)
-        trinity = Agent(name="Trinity", model=default_model_instance, instructions=trinity_instructions, tools=[execute_shell_command], mcp_servers=mcp_servers)
-        oracle = Agent(name="Oracle", model=default_model_instance, instructions=oracle_instructions, tools=[])
-        cypher = Agent(name="Cypher", model=default_model_instance, instructions=cypher_instructions, tools=[execute_shell_command])
-        tank = Agent(name="Tank", model=default_model_instance, instructions=tank_instructions, tools=[execute_shell_command])
-
-        morpheus = Agent(
-             name="Morpheus", model=default_model_instance, instructions=morpheus_instructions,
-             tools=[
-                 execute_shell_command,
-                 neo.as_tool(tool_name="Neo", tool_description="Delegate coding, review, or documentation tasks to Neo."),
-                 trinity.as_tool(tool_name="Trinity", tool_description="Delegate information gathering or reconnaissance shell commands to Trinity."),
-                 cypher.as_tool(tool_name="Cypher", tool_description="Delegate tasks to Cypher for alternative perspectives or direct shell execution if needed."),
-                 tank.as_tool(tool_name="Tank", tool_description="Delegate specific shell command execution to Tank."),
-             ],
-             mcp_servers=mcp_servers
-        )
-        logger.debug("NebulaShellzzar agent team created. Morpheus is the starting agent.") # Changed to DEBUG
-        return morpheus
-
-    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], **kwargs):
-        """Main execution entry point for the NebulaShellzzar blueprint."""
-        logger.info("NebuchaShellzzarBlueprint run method called.")
-        instruction = messages[-1].get("content", "") if messages else ""
-        from agents import Runner
-        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:
-            runner_gen = Runner.run(self.create_starting_agent([]), instruction)
-            while True:
-                now = time.time()
-                try:
-                    chunk = next(runner_gen)
-                    result_chunks.append(chunk)
-                    # If chunk is a final result, wrap and yield
-                    if chunk and isinstance(chunk, dict) and "messages" in chunk:
-                        content = chunk["messages"][0]["content"] if chunk["messages"] else ""
-                        summary = ux.summary("Operation", len(result_chunks), {"instruction": instruction[:40]})
-                        box = ux.ansi_emoji_box(
-                            title="NebulaShellzzar Result",
-                            content=content,
-                            summary=summary,
-                            params={"instruction": instruction[:40]},
-                            result_count=len(result_chunks),
-                            op_type="run",
-                            status="success"
-                        )
-                        yield {"messages": [{"role": "assistant", "content": box}]}
-                    else:
-                        yield chunk
-                    yielded_spinner = False
-                except StopIteration:
-                    break
-                except Exception:
-                    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
-            if not result_chunks and not yielded_spinner:
-                yield {"messages": [{"role": "assistant", "content": ux.spinner(0)}]}
-        except Exception as e:
-            logger.error(f"Error during NebulaShellzzar run: {e}", exc_info=True)
-            yield {"messages": [{"role": "assistant", "content": f"An error occurred: {e}"}]}
-
-if __name__ == "__main__":
-    import asyncio
-    import json
-    messages = [
-        {"role": "user", "content": "Shell out to the stars."}
-    ]
-    blueprint = NebuchaShellzzarBlueprint(blueprint_id="demo-1")
-    async def run_and_print():
-        async for response in blueprint.run(messages):
-            print(json.dumps(response, indent=2))
-    asyncio.run(run_and_print())