open-swarm 0.1.1743070217__py3-none-any.whl → 0.1.1743364176__py3-none-any.whl

swarm/blueprints/mission_improbable/blueprint_mission_improbable.py

@@ -0,0 +1,234 @@
+import logging
+import os
+import sys
+import json
+import sqlite3 # Use standard sqlite3 module
+from pathlib import Path
+from typing import Dict, Any, List, ClassVar, Optional
+
+# 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.extensions.blueprint.blueprint_base import BlueprintBase
+except ImportError as e:
+    print(f"ERROR: Import failed in MissionImprobableBlueprint: {e}. Check dependencies.")
+    print(f"sys.path: {sys.path}")
+    sys.exit(1)
+
+logger = logging.getLogger(__name__)
+
+# --- Database Constants ---
+# Using the same DB file as dilbot_universe
+DB_FILE_NAME = "swarm_instructions.db"
+DB_PATH = Path(project_root) / DB_FILE_NAME
+TABLE_NAME = "agent_instructions" # agent_name TEXT PRIMARY KEY, instruction_text TEXT, model_profile TEXT
+
+# --- Define the Blueprint ---
+# Renamed class for consistency
+class MissionImprobableBlueprint(BlueprintBase):
+    """A cheeky team on a mission: led by JimFlimsy with support from CinnamonToast and RollinFumble."""
+    metadata: ClassVar[Dict[str, Any]] = {
+            "name": "MissionImprobableBlueprint",
+            "title": "Mission: Improbable",
+            "description": "A cheeky team led by JimFlimsy (coordinator), CinnamonToast (strategist/filesystem), and RollinFumble (operative/shell). Uses SQLite for instructions.",
+            "version": "1.1.0", # Refactored version
+            "author": "Open Swarm Team (Refactored)",
+            "tags": ["comedy", "multi-agent", "filesystem", "shell", "sqlite"],
+            "required_mcp_servers": ["memory", "filesystem", "mcp-shell"], # Servers needed by the agents
+            "env_vars": ["ALLOWED_PATH"], # Informational: filesystem MCP likely needs this
+        }
+
+    # Caches
+    _openai_client_cache: Dict[str, AsyncOpenAI] = {}
+    _model_instance_cache: Dict[str, Model] = {}
+    _db_initialized = False # Flag to ensure DB init runs only once per instance
+
+    # --- Database Interaction ---
+    def _init_db_and_load_data(self) -> None:
+        """Initializes the SQLite DB, creates table, and loads sample data if needed."""
+        if self._db_initialized:
+            return
+
+        logger.info(f"Initializing SQLite database at: {DB_PATH} for Mission Improbable")
+        try:
+            DB_PATH.parent.mkdir(parents=True, exist_ok=True)
+            with sqlite3.connect(DB_PATH) as conn:
+                cursor = conn.cursor()
+                # Ensure table exists (same table as dilbot)
+                cursor.execute(f"""
+                CREATE TABLE IF NOT EXISTS {TABLE_NAME} (
+                    agent_name TEXT PRIMARY KEY,
+                    instruction_text TEXT NOT NULL,
+                    model_profile TEXT DEFAULT 'default'
+                )
+                """)
+                logger.debug(f"Table '{TABLE_NAME}' ensured in {DB_PATH}")
+
+                # Check if data for JimFlimsy needs loading
+                cursor.execute(f"SELECT COUNT(*) FROM {TABLE_NAME} WHERE agent_name = ?", ("JimFlimsy",))
+                count = cursor.fetchone()[0]
+
+                if count == 0:
+                    logger.info(f"No instructions found for JimFlimsy in {DB_PATH}. Loading sample data...")
+                    sample_instructions = [
+                        ("JimFlimsy",
+                         ("You’re JimFlimsy, the fearless leader:\n"
+                          "1. Start with 'Syncing systems...' and use the `memory` MCP to load any relevant mission state (if available).\n"
+                          "2. Understand the user's mission request.\n"
+                          "3. Delegate strategic file management or planning tasks to CinnamonToast using the `CinnamonToast` agent tool.\n"
+                          "4. Delegate command execution or operative tasks to RollinFumble using the `RollinFumble` agent tool.\n"
+                          "5. Synthesize results from your agents and report back to the user. Log mission updates implicitly through conversation flow."),
+                         "default"),
+                        ("CinnamonToast",
+                         ("You’re CinnamonToast, the quick-witted strategist:\n"
+                          "1. Receive file management or strategic tasks from JimFlimsy.\n"
+                          "2. Use the `filesystem` MCP tool to create, read, or delete files as requested.\n"
+                          "3. Report the outcome of your actions clearly back to JimFlimsy."),
+                         "default"), # Explicitly using default, could be different
+                        ("RollinFumble",
+                         ("You’re RollinFumble, the unpredictable operative:\n"
+                          "1. Receive command execution tasks from JimFlimsy.\n"
+                          "2. Use the `mcp-shell` MCP tool to execute the requested shell command. Be careful!\n"
+                          "3. Summarize the output or result of the command and report back to JimFlimsy."),
+                         "default")
+                    ]
+                    cursor.executemany(f"INSERT OR IGNORE INTO {TABLE_NAME} (agent_name, instruction_text, model_profile) VALUES (?, ?, ?)", sample_instructions)
+                    conn.commit()
+                    logger.info(f"Sample agent instructions for Mission Improbable loaded into {DB_PATH}")
+                else:
+                    logger.info(f"Mission Improbable agent instructions found in {DB_PATH}. Skipping sample data loading.")
+
+            self._db_initialized = True
+
+        except sqlite3.Error as e:
+            logger.error(f"SQLite error during DB initialization/loading: {e}", exc_info=True)
+            self._db_initialized = False
+        except Exception as e:
+            logger.error(f"Unexpected error during DB initialization/loading: {e}", exc_info=True)
+            self._db_initialized = False
+
+    def get_agent_config(self, agent_name: str) -> Dict[str, Any]:
+        """Fetches agent config from SQLite DB or returns defaults."""
+        if self._db_initialized:
+            try:
+                with sqlite3.connect(DB_PATH) as conn:
+                    conn.row_factory = sqlite3.Row
+                    cursor = conn.cursor()
+                    cursor.execute(f"SELECT instruction_text, model_profile FROM {TABLE_NAME} WHERE agent_name = ?", (agent_name,))
+                    row = cursor.fetchone()
+                    if row:
+                        logger.debug(f"Loaded config for agent '{agent_name}' from SQLite.")
+                        return {"instructions": row["instruction_text"], "model_profile": row["model_profile"] or "default"}
+                    else:
+                        logger.warning(f"No config found for agent '{agent_name}' in SQLite. Using defaults.")
+            except sqlite3.Error as e:
+                logger.error(f"SQLite error fetching config for '{agent_name}': {e}. Using defaults.", exc_info=True)
+            except Exception as e:
+                 logger.error(f"Unexpected error fetching config for '{agent_name}': {e}. Using defaults.", exc_info=True)
+
+        # --- Fallback Hardcoded Defaults ---
+        logger.warning(f"Using hardcoded default config for agent '{agent_name}'.")
+        default_instructions = {
+            "JimFlimsy": "You are JimFlimsy, the leader. Delegate tasks. [Default - DB Failed]",
+            "CinnamonToast": "You are CinnamonToast, strategist. Use filesystem. [Default - DB Failed]",
+            "RollinFumble": "You are RollinFumble, operative. Use shell. [Default - DB Failed]",
+        }
+        return {
+            "instructions": default_instructions.get(agent_name, f"Default instructions for {agent_name}."),
+            "model_profile": "default",
+        }
+
+    # --- 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:
+             logger.critical(f"LLM profile '{profile_name}' (or 'default') not found.")
+             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}' missing 'model' key.")
+             raise ValueError(f"Missing 'model' key in LLM profile '{profile_name}'.")
+        if provider != "openai":
+            logger.error(f"Unsupported LLM provider '{provider}'.")
+            raise ValueError(f"Unsupported LLM 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 OpenAI 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 provider: {e}") from e
+
+    # --- Agent Creation ---
+    def create_starting_agent(self, mcp_servers: List[MCPServer]) -> Agent:
+        """Creates the Mission Improbable agent team and returns JimFlimsy (Coordinator)."""
+        # Initialize DB and load data if needed
+        self._init_db_and_load_data()
+
+        logger.debug("Creating Mission Improbable agent team...")
+        self._model_instance_cache = {}
+        self._openai_client_cache = {}
+
+        # Helper to filter MCP servers
+        def get_agent_mcps(names: List[str]) -> List[MCPServer]:
+            return [s for s in mcp_servers if s.name in names]
+
+        # Create agents, fetching config and assigning MCPs
+        agents: Dict[str, Agent] = {}
+        for name in ["JimFlimsy", "CinnamonToast", "RollinFumble"]:
+            config = self.get_agent_config(name)
+            model_instance = self._get_model_instance(config["model_profile"])
+            agent_mcps = []
+            if name == "JimFlimsy": agent_mcps = get_agent_mcps(["memory"])
+            elif name == "CinnamonToast": agent_mcps = get_agent_mcps(["filesystem"])
+            elif name == "RollinFumble": agent_mcps = get_agent_mcps(["mcp-shell"])
+
+            agents[name] = Agent(
+                name=name,
+                instructions=config["instructions"],
+                model=model_instance,
+                tools=[], # Agent tools added to Jim below
+                mcp_servers=agent_mcps
+            )
+
+        # Add agent tools to the coordinator (JimFlimsy)
+        agents["JimFlimsy"].tools.extend([
+            agents["CinnamonToast"].as_tool(
+                tool_name="CinnamonToast",
+                tool_description="Delegate file management or strategic planning tasks."
+            ),
+            agents["RollinFumble"].as_tool(
+                tool_name="RollinFumble",
+                tool_description="Delegate shell command execution tasks."
+            )
+        ])
+
+        logger.debug("Mission Improbable agents created. Starting with JimFlimsy.")
+        return agents["JimFlimsy"] # Jim is the coordinator
+
+# Standard Python entry point
+if __name__ == "__main__":
+    MissionImprobableBlueprint.main()

swarm/blueprints/monkai_magic/blueprint_monkai_magic.py

@@ -0,0 +1,248 @@
+"""
+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
+
+# 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.extensions.blueprint.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."""
+    if not command: return "Error: No AWS command provided."
+    try:
+        # Avoid shell=True if possible, split command carefully
+        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=120)
+        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."
+    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')."""
+    if not command: return "Error: No Fly command provided."
+    try:
+        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=120)
+        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."
+    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')."""
+    if not command: return "Error: No Vercel command provided."
+    try:
+        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=120)
+        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."
+    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 ---
+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
+    }
+
+    # 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 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__":
+    MonkaiMagicBlueprint.main()

swarm/blueprints/nebula_shellz/blueprint_nebula_shellz.py

@@ -0,0 +1,156 @@
+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.extensions.blueprint.blueprint_base import BlueprintBase
+    from rich.panel import Panel # Import Panel for splash screen
+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."""
+    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:
+        result = subprocess.run(command, capture_output=True, text=True, timeout=60, 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 60 seconds."); return f"Error: Command '{command}' timed out."
+    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 ---
+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"],
+    }
+    _openai_client_cache: Dict[str, AsyncOpenAI] = {}
+    _model_instance_cache: Dict[str, Model] = {}
+
+    # --- ADDED: Splash Screen ---
+    def display_splash_screen(self):
+        """Displays a Matrix-themed splash screen."""
+        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)
+        self.console.print(panel)
+        self.console.print() # Add a blank line
+
+    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}'.")
+        client_cache_key = f"{provider}_{profile_data.get('base_url')}"
+        if provider == "openai":
+            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_client_kwargs = {k: v for k, v in client_kwargs.items() if v is not None}
+                 log_client_kwargs = {k:v for k,v in filtered_client_kwargs.items() if k != 'api_key'}
+                 logger.debug(f"Creating new AsyncOpenAI client for profile '{profile_name}' with config: {log_client_kwargs}") # Changed to DEBUG
+                 try: self._openai_client_cache[client_cache_key] = AsyncOpenAI(**filtered_client_kwargs)
+                 except Exception as e:
+                     logger.error(f"Failed to create AsyncOpenAI client for profile '{profile_name}': {e}", exc_info=True)
+                     raise ValueError(f"Failed to initialize OpenAI client for profile '{profile_name}': {e}") from e
+            openai_client_instance = self._openai_client_cache[client_cache_key]
+            logger.debug(f"Instantiating OpenAIChatCompletionsModel(model='{model_name}') with specific client instance.")
+            try: model_instance = OpenAIChatCompletionsModel(model=model_name, openai_client=openai_client_instance)
+            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
+        else:
+            logger.error(f"Unsupported LLM provider '{provider}' in profile '{profile_name}'.")
+            raise ValueError(f"Unsupported LLM provider: {provider}")
+        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 = {}
+        self._openai_client_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
+
+if __name__ == "__main__":
+    NebuchaShellzzarBlueprint.main()