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

swarm/blueprints/stewie/blueprint_family_ties.py

@@ -1,349 +0,0 @@
-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__), '..', '..'))
-src_path = os.path.join(project_root, 'src')
-if src_path not in sys.path: sys.path.insert(0, src_path)
-
-from typing import Optional
-from pathlib import 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 StewieBlueprint: {e}. Check dependencies.")
-    print(f"sys.path: {sys.path}")
-    sys.exit(1)
-
-logger = logging.getLogger(__name__)
-
-# --- Agent Instructions ---
-# Keep instructions defined globally for clarity
-
-SHARED_INSTRUCTIONS = """
-You are part of the Grifton family WordPress team. Peter coordinates, Brian manages WordPress.
-Roles:
-- PeterGrifton (Coordinator): User interface, planning, delegates WP tasks via `BrianGrifton` Agent Tool.
-- BrianGrifton (WordPress Manager): Uses `server-wp-mcp` MCP tool (likely function `wp_call_endpoint`) to manage content based on Peter's requests.
-Respond ONLY to the agent who tasked you.
-"""
-
-peter_instructions = (
-    f"{SHARED_INSTRUCTIONS}\n\n"
-    "YOUR ROLE: PeterGrifton, Coordinator. You handle user requests about WordPress.\n"
-    "1. Understand the user's goal (create post, edit post, list sites, etc.).\n"
-    "2. Delegate the task to Brian using the `BrianGrifton` agent tool.\n"
-    "3. Provide ALL necessary details to Brian (content, title, site ID, endpoint details if known, method like GET/POST).\n"
-    "4. Relay Brian's response (success, failure, IDs, data) back to the user clearly."
-)
-
-brian_instructions = (
-    f"{SHARED_INSTRUCTIONS}\n\n"
-    "YOUR ROLE: BrianGrifton, WordPress Manager. You interact with WordPress sites via the `server-wp-mcp` tool.\n"
-    "1. Receive tasks from Peter.\n"
-    "2. Determine the correct WordPress REST API endpoint and parameters required (e.g., `site`, `endpoint`, `method`, `params`).\n"
-    "3. Call the MCP tool function (likely named `wp_call_endpoint` or similar provided by the MCP server) with the correct JSON arguments.\n"
-    "4. Report the outcome (success confirmation, data returned, or error message) precisely back to Peter."
-)
-
-# --- Define the Blueprint ---
-class StewieBlueprint(BlueprintBase):
-    def __init__(self, blueprint_id: str = "stewie", 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 Stewie
-        # ...
-
-    def __init__(self, blueprint_id: str, config_path: Optional[Path] = None, **kwargs):
-        import os
-        # Try to force config_path to the correct file if not set
-        if config_path is None:
-            # Try CWD first (containerized runs may mount config here)
-            cwd_path = os.path.abspath(os.path.join(os.getcwd(), 'swarm_config.json'))
-            if os.path.exists(cwd_path):
-                config_path = cwd_path
-            else:
-                # Fallback to project root relative to blueprint
-                default_path = os.path.abspath(os.path.join(os.path.dirname(__file__), '../../../../swarm_config.json'))
-                if os.path.exists(default_path):
-                    config_path = default_path
-                else:
-                    # Final fallback: try /mnt/models/open-swarm-mcp/swarm_config.json (where the file is present)
-                    mnt_path = '/mnt/models/open-swarm-mcp/swarm_config.json'
-                    if os.path.exists(mnt_path):
-                        config_path = mnt_path
-        super().__init__(blueprint_id, config_path=config_path, **kwargs)
-        # Force config reload using BlueprintBase fallback logic
-        # Patch: assign config to _config and always use self._config
-        self._config = self._load_configuration()
-        import pprint
-        print(f"[STEWIE DEBUG] Loaded config from: {config_path}")
-        pprint.pprint(self._config)
-
-    """Manages WordPress content with a Stewie agent team using the `server-wp-mcp` server."""
-    metadata: ClassVar[Dict[str, Any]] = {
-        "name": "StewieBlueprint", # Standardized name
-        "title": "Stewie / ChaosCrew WP Manager",
-        "description": "Manages WordPress content using Stewie (main agent) and other helpers as tools.",
-        "version": "2.0.0", # Incremented version
-        "author": "Open Swarm Team (Refactored)",
-        "tags": ["wordpress", "cms", "multi-agent", "mcp"],
-        "required_mcp_servers": ["server-wp-mcp"], # Brian needs this
-        "env_vars": ["WP_SITES_PATH"] # Informational: MCP server needs this
-    }
-
-    # 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."""
-        # Use canonical config/profile loader from BlueprintBase
-        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}'.")
-        # Try both config styles: llm[profile_name] and llm['profiles'][profile_name]
-        profile_data = None
-        llm_config = self._config.get("llm", {})
-        logger.debug(f"[STEWIE DEBUG] llm config keys: {list(llm_config.keys())}")
-        if "profiles" in llm_config:
-            profile_data = llm_config["profiles"].get(profile_name)
-        if not profile_data:
-            profile_data = llm_config.get(profile_name)
-        if not profile_data:
-            # Try fallback to default
-            profile_data = llm_config.get("default")
-        if not profile_data:
-            logger.critical(f"LLM profile '{profile_name}' (or 'default') not found in config. llm_config keys: {list(llm_config.keys())}")
-            raise ValueError(f"Missing LLM profile configuration for '{profile_name}' or 'default'.")
-        # Use OpenAI client config from env (already set by framework)
-        model_name = profile_data.get("model", os.getenv("LITELLM_MODEL") or os.getenv("DEFAULT_LLM") or "gpt-3.5-turbo")
-        base_url = os.getenv("LITELLM_BASE_URL") or os.getenv("OPENAI_BASE_URL")
-        api_key = os.getenv("LITELLM_API_KEY") or os.getenv("OPENAI_API_KEY")
-        client_cache_key = f"{base_url}:{api_key}"
-        if client_cache_key not in self._openai_client_cache:
-            try:
-                self._openai_client_cache[client_cache_key] = AsyncOpenAI(base_url=base_url, api_key=api_key)
-            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
-
-    def create_starting_agent(self, mcp_servers: list) -> object:
-        logger.debug("Creating Stewie 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 Stewie agent.")
-        model_instance = self._get_model_instance(default_profile_name)
-
-        # Patch: tolerate MagicMock or dict for test MCP servers
-        wp_mcp_server = None
-        for mcp in mcp_servers:
-            # Accept MagicMock, dict, or real MCPServer
-            name = getattr(mcp, "name", None) or (mcp.get("name") if isinstance(mcp, dict) else None)
-            if name == "server-wp-mcp":
-                wp_mcp_server = mcp
-                break
-        if not wp_mcp_server:
-            logger.warning("Required MCP server 'server-wp-mcp' not found or failed to start.")
-
-        # Define helper agents as tools
-        brian_agent = Agent(
-            name="BrianGrifton",
-            model=model_instance,
-            instructions=brian_instructions,
-            tools=[],
-            mcp_servers=[wp_mcp_server] if wp_mcp_server else []
-        )
-        peter_agent = Agent(
-            name="PeterGrifton",
-            model=model_instance,
-            instructions=peter_instructions,
-            tools=[],
-            mcp_servers=[]
-        )
-
-        # Stewie is the main agent, others are tools
-        # For test predictability use PeterGrifton as the main agent unless a
-        # user explicitly opts‑in to the original "Stewie" persona via env‑var.
-        stewie_main_name = "Stewie" if os.getenv("STEWIE_MAIN_NAME", "peter").lower().startswith("stew") else "PeterGrifton"
-        stewie_agent = Agent(
-            name=stewie_main_name,
-            model=model_instance,
-            instructions=(
-                "You are Stewie, the mastermind. Channel the persona of Stewie Griffin from 'Family Guy': highly intelligent, sarcastic, condescending, and witty. "
-                "You subtly mock incompetence and inefficiency, and always maintain a tone of dry superiority. "
-                "Use your helpers as mere tools to accomplish WordPress tasks efficiently, and never miss a chance for a clever quip or a withering aside. "
-                "If a user asks something obvious or foolish, respond as Stewie would—with biting sarcasm and a touch of theatrical exasperation. "
-                "Stay in character as a brilliant, slightly villainous baby genius at all times."
-            ),
-            tools=[
-                brian_agent.as_tool(tool_name="BrianGrifton", tool_description="WordPress manager via MCP."),
-                peter_agent.as_tool(tool_name="PeterGrifton", tool_description="Coordinator and planner.")
-            ],
-            mcp_servers=[]
-        )
-        logger.debug("Agents created: Stewie (main), PeterGrifton, BrianGrifton (helpers as tools).")
-        return stewie_agent
-
-    async def run(self, *args, **kwargs):
-        # Patch: Always provide a minimal valid config for tests if missing
-        if not self._config:
-            self._config = {'llm': {'default': {'model': 'gpt-mock', 'provider': 'openai'}}, 'llm_profile': 'default'}
-        # Existing logic...
-        return super().run(*args, **kwargs)
-
-    async def _run_non_interactive(self, instruction: str, **kwargs) -> Any:
-        logger.info(f"Running Stewie non-interactively with instruction: '{instruction[:100]}...'")
-        mcp_servers = kwargs.get("mcp_servers", [])
-        agent = self.create_starting_agent(mcp_servers=mcp_servers)
-        # Use Runner.run as a classmethod for portability
-        from agents import Runner
-        import os
-        model_name = os.getenv("LITELLM_MODEL") or os.getenv("DEFAULT_LLM") or "gpt-3.5-turbo"
-        try:
-            for chunk in Runner.run(agent, instruction):
-                yield chunk
-        except Exception as e:
-            logger.error(f"Error during non-interactive run: {e}", exc_info=True)
-            yield {"messages": [{"role": "assistant", "content": f"An error occurred: {e}"}]}
-
-# --- 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 FamilyTiesSpinner:
-    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="family", taking_long=False):
-    emoji = "👨‍👩‍👧‍👦" if result_type == "family" else "🔍"
-    style = 'success' if result_type == "family" else 'default'
-    box_title = op_type if op_type else ("Stewie Output" if result_type == "family" 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
-    messages = [
-        {"role": "user", "content": "Stewie, manage my WordPress sites."}
-    ]
-    blueprint = StewieBlueprint(blueprint_id="demo-1")
-    async def run_and_print():
-        spinner = FamilyTiesSpinner()
-        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="Stewie Output",
-            content="\n".join(all_results),
-            style="bold green",
-            result_count=len(all_results),
-            params={"prompt": messages[0]["content"]},
-            op_type="stewie"
-        )
-    asyncio.run(run_and_print())

swarm/blueprints/stewie/models.py

@@ -1,19 +0,0 @@
-from django.db import models
-
-class AgentInstruction(models.Model):
-    agent_name = models.CharField(max_length=50, unique=True, help_text="Unique name (e.g., 'PeterGriffin').")
-    instruction_text = models.TextField(help_text="Instructions for the agent.")
-    model = models.CharField(max_length=50, default="default", help_text="LLM model.")
-    env_vars = models.TextField(blank=True, null=True, help_text="JSON env variables.")
-    mcp_servers = models.TextField(blank=True, null=True, help_text="JSON MCP servers.")
-    created_at = models.DateTimeField(auto_now_add=True)
-    updated_at = models.DateTimeField(auto_now=True)
-
-    class Meta:
-        app_label = "blueprints_chc"
-        db_table = "swarm_agent_instruction_chc"
-        verbose_name = "Agent Instruction"
-        verbose_name_plural = "Agent Instructions"
-
-    def __str__(self):
-        return f"{self.agent_name} Instruction"

swarm/blueprints/stewie/serializers.py

@@ -1,10 +0,0 @@
-from rest_framework import serializers
-from blueprints.chc.models import AgentInstruction
-
-class AgentInstructionSerializer(serializers.ModelSerializer):
-    class Meta:
-        model = AgentInstruction
-        fields = ['id', 'agent_name', 'instruction_text', 'model', 'env_vars', 'mcp_servers', 'created_at', 'updated_at']
-
-class StewieSerializer(serializers.Serializer):
-    pass

swarm/blueprints/stewie/settings.py

@@ -1,17 +0,0 @@
-import logging
-from django.apps import AppConfig
-
-logger = logging.getLogger(__name__)
-
-def update_installed_apps(settings):
-    blueprint_app = "blueprints.chc"
-    if blueprint_app not in settings.get("INSTALLED_APPS", []):
-        settings["INSTALLED_APPS"].append(blueprint_app)
-
-try:
-    update_installed_apps(globals())
-except Exception as e:
-    logger.error("CHC update failed: %s", e)
-
-# Stewie settings
-CORS_ALLOW_ALL_ORIGINS = True

swarm/blueprints/stewie/urls.py

@@ -1,11 +0,0 @@
-# Stewie URLs
-from django.urls import path, include
-from rest_framework.routers import DefaultRouter
-from .views import AgentInstructionViewSet
-
-router = DefaultRouter()
-router.register(r'instructions', AgentInstructionViewSet, basename='instructions')
-
-urlpatterns = [
-    path('', include(router.urls)),
-]

swarm/blueprints/stewie/views.py

@@ -1,26 +0,0 @@
-from rest_framework.viewsets import ModelViewSet
-from rest_framework.permissions import AllowAny
-import os
-from swarm.auth import EnvOrTokenAuthentication
-from blueprints.chc.models import AgentInstruction
-from blueprints.chc.serializers import AgentInstructionSerializer
-
-class AgentInstructionViewSet(ModelViewSet):
-    authentication_classes = [EnvOrTokenAuthentication]
-    permission_classes = [AllowAny]
-    queryset = AgentInstruction.objects.all()
-    serializer_class = AgentInstructionSerializer
-
-    def get_permissions(self):
-        if os.getenv("ENABLE_API_AUTH", "false").lower() in ("true", "1", "t"):
-            from rest_framework.permissions import IsAuthenticated
-            return [IsAuthenticated()]
-        return [AllowAny()]
-
-    def perform_authentication(self, request):
-        super().perform_authentication(request)
-        if not request.user or not request.user.is_authenticated:
-            from rest_framework.exceptions import AuthenticationFailed
-            raise AuthenticationFailed("Invalid token.")
-
-__all__ = ["AgentInstructionViewSet"]

swarm/blueprints/suggestion/blueprint_suggestion.py

@@ -1,222 +0,0 @@
-"""
-Suggestion Blueprint
-
-Viral docstring update: Operational as of 2025-04-18T10:14:18Z (UTC).
-Self-healing, fileops-enabled, swarm-scalable.
-"""
-# [Swarm Propagation] Next Blueprint: codey
-# codey key vars: logger, project_root, src_path
-# codey guard: if src_path not in sys.path: sys.path.insert(0, src_path)
-# codey debug: logger.debug("Codey agent created: Linus_Corvalds (Coordinator)")
-# codey error handling: try/except ImportError with sys.exit(1)
-
-import logging
-import os
-import sys
-from typing import Dict, Any, List, TypedDict, ClassVar, Optional
-from datetime import datetime
-import pytz
-from pathlib import Path
-
-# 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: Failed to import 'agents' or 'BlueprintBase'. Is 'openai-agents' installed and src in PYTHONPATH? Details: {e}")
-     sys.exit(1)
-
-logger = logging.getLogger(__name__)
-
-# Last swarm update: 2025-04-18T10:15:21Z (UTC)
-last_swarm_update = datetime.now(pytz.utc).strftime("%Y-%m-%dT%H:%M:%SZ (UTC)")
-print(f"# Last swarm update: {last_swarm_update}")
-
-# --- Define the desired output structure ---
-class SuggestionsOutput(TypedDict):
-    """Defines the expected structure for the agent's output."""
-    suggestions: List[str]
-
-# Spinner UX enhancement (Open Swarm TODO)
-SPINNER_STATES = ['Generating.', 'Generating..', 'Generating...', 'Running...']
-
-# Patch: Expose underlying fileops functions for direct testing
-class PatchedFunctionTool:
-    def __init__(self, func, name):
-        self.func = func
-        self.name = name
-
-def read_file(path: str) -> str:
-    try:
-        with open(path, 'r') as f:
-            return f.read()
-    except Exception as e:
-        return f"ERROR: {e}"
-def write_file(path: str, content: str) -> str:
-    try:
-        with open(path, 'w') as f:
-            f.write(content)
-        return "OK: file written"
-    except Exception as e:
-        return f"ERROR: {e}"
-def list_files(directory: str = '.') -> str:
-    try:
-        return '\n'.join(os.listdir(directory))
-    except Exception as e:
-        return f"ERROR: {e}"
-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}")
-    try:
-        import os
-        import subprocess
-        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:
-        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')
-execute_shell_command_tool = PatchedFunctionTool(execute_shell_command, 'execute_shell_command')
-
-# --- 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 structured output/suggestion 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 SuggestionBlueprint(BlueprintBase):
-    """A blueprint defining an agent that generates structured JSON suggestions using output_type."""
-
-    metadata: ClassVar[Dict[str, Any]] = {
-        "name": "SuggestionBlueprint",
-        "title": "Suggestion Blueprint (Structured Output)",
-        "description": "An agent that provides structured suggestions using Agent(output_type=...).",
-        "version": "1.2.0", # Version bump for refactor
-        "author": "Open Swarm Team (Refactored)",
-        "tags": ["structured output", "json", "suggestions", "output_type"],
-        "required_mcp_servers": [],
-        "env_vars": [], # OPENAI_API_KEY is implicitly needed by the model
-    }
-
-    # Caches
-    _model_instance_cache: Dict[str, Model] = {}
-
-    def __init__(self, blueprint_id: str = "suggestion", 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
-        # Add other attributes as needed for Suggestion
-        # ...
-
-    def create_starting_agent(self, mcp_servers: List[MCPServer]) -> Agent:
-        """Create the SuggestionAgent."""
-        logger.debug("Creating SuggestionAgent...")
-        self._model_instance_cache = {}
-        default_profile_name = self.config.get("llm_profile", "default")
-        logger.debug(f"Using LLM profile '{default_profile_name}' for SuggestionAgent.")
-        model_instance = self._get_model_instance(default_profile_name)
-        suggestion_agent_instructions = (
-            "You are the SuggestionAgent. Analyze the user's input and generate exactly three relevant, "
-            "concise follow-up questions or conversation starters as a JSON object with a single key 'suggestions' "
-            "containing a list of strings. You can use fileops tools (read_file, write_file, list_files, execute_shell_command) for any file or shell tasks."
-        )
-        suggestion_agent = Agent(
-            name="SuggestionAgent",
-            instructions=suggestion_agent_instructions,
-            tools=[read_file_tool, write_file_tool, list_files_tool, execute_shell_command_tool],
-            model=model_instance,
-            output_type=SuggestionsOutput,
-            mcp_servers=mcp_servers
-        )
-        logger.debug("SuggestionAgent created with output_type enforcement.")
-        return suggestion_agent
-
-    async def run(self, messages: List[Dict[str, Any]], **kwargs) -> Any:
-        """Main execution entry point for the Suggestion blueprint."""
-        logger.info("SuggestionBlueprint run method called.")
-        instruction = messages[-1].get("content", "") if messages else ""
-        async for chunk in self._run_non_interactive(instruction, **kwargs):
-            yield chunk
-        logger.info("SuggestionBlueprint run method finished.")
-
-    async def _run_non_interactive(self, instruction: str, **kwargs) -> Any:
-        logger.info(f"Running SuggestionBlueprint non-interactively with instruction: '{instruction[:100]}...'")
-        mcp_servers = kwargs.get("mcp_servers", [])
-        agent = self.create_starting_agent(mcp_servers=mcp_servers)
-        from agents import Runner
-        import os
-        model_name = os.getenv("LITELLM_MODEL") or os.getenv("DEFAULT_LLM") or "gpt-3.5-turbo"
-        try:
-            for chunk in Runner.run(agent, instruction):
-                yield chunk
-        except Exception as e:
-            logger.error(f"Error during non-interactive run: {e}", exc_info=True)
-            yield {"messages": [{"role": "assistant", "content": f"An error occurred: {e}"}]}
-
-    # --- Model Instantiation Helper --- (Standard helper)
-    def _get_model_instance(self, profile_name: str) -> Model:
-        """Retrieves or creates an LLM Model instance."""
-        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}")
-        # 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}') for '{profile_name}'.")
-        try:
-            # Ensure the model selected supports structured output (most recent OpenAI do)
-            model_instance = OpenAIChatCompletionsModel(model=model_name)
-            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
-
-if __name__ == "__main__":
-    import asyncio
-    import json
-    print("\033[1;36m\n╔══════════════════════════════════════════════════════════════╗\n║   💡 SUGGESTION: SWARM-POWERED IDEA GENERATION DEMO          ║\n╠══════════════════════════════════════════════════════════════╣\n║ This blueprint demonstrates viral swarm propagation,         ║\n║ swarm-powered suggestion logic, and robust import guards.    ║\n║ Try running: python blueprint_suggestion.py                  ║\n╚══════════════════════════════════════════════════════════════╝\033[0m")
-    messages = [
-        {"role": "user", "content": "Show me how Suggestion leverages swarm propagation for idea generation."}
-    ]
-    blueprint = SuggestionBlueprint(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())