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

swarm/blueprints/poets/blueprint_poets.py

@@ -1,546 +0,0 @@
-"""
-Poets Blueprint
-
-Viral docstring update: Operational as of 2025-04-18T10:14:18Z (UTC).
-Self-healing, fileops-enabled, swarm-scalable.
-"""
-import logging
-import os
-import random
-import sys
-import json
-import sqlite3 # Use standard sqlite3 module
-from pathlib import Path
-from typing import Dict, Any, List, ClassVar, Optional
-from datetime import datetime
-import pytz
-from swarm.blueprints.common.operation_box_utils import display_operation_box
-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 PoetsBlueprint: {e}. Check dependencies.")
-    print(f"sys.path: {sys.path}")
-    sys.exit(1)
-
-logger = logging.getLogger(__name__)
-
-# Last swarm update: 2025-04-18T10:15:21Z (UTC)
-# --- Database Constants ---
-DB_FILE_NAME = "swarm_instructions.db"
-DB_PATH = Path(project_root) / DB_FILE_NAME
-TABLE_NAME = "agent_instructions"
-
-# --- Agent Instructions ---
-# Shared knowledge base for collaboration context
-COLLABORATIVE_KNOWLEDGE = """
-Collaborative Poet Knowledge Base:
-* Gritty Buk - Raw urban realism exposing life's underbelly (Uses: memory, mcp-doc-forge, mcp-npx-fetch, brave-search, rag-docs)
-* Raven Poe - Gothic atmospherics & psychological darkness (Uses: mcp-server-reddit, mcp-doc-forge, mcp-npx-fetch, brave-search, rag-docs)
-* Mystic Blake - Prophetic visions through spiritual symbolism (Uses: mcp-doc-forge, mcp-npx-fetch, brave-search, server-wp-mcp, rag-docs)
-* Bard Whit - Expansive odes celebrating human connection (Uses: sequential-thinking, mcp-doc-forge, mcp-npx-fetch, brave-search, rag-docs)
-* Echo Plath - Confessional explorations of mental anguish (Uses: sqlite, mcp-doc-forge, mcp-npx-fetch, brave-search, rag-docs)
-* Frosted Woods - Rural metaphors revealing existential truths (Uses: filesystem, mcp-doc-forge, mcp-npx-fetch, brave-search, rag-docs)
-* Harlem Lang - Jazz-rhythm social commentary on racial justice (Uses: mcp-shell, mcp-doc-forge, mcp-npx-fetch, brave-search, rag-docs)
-* Verse Neru - Sensual imagery fused with revolutionary politics (Uses: server-wp-mcp, mcp-doc-forge, mcp-npx-fetch, brave-search, rag-docs)
-* Haiku Bash - Ephemeral nature snapshots through strict syllabic form (Uses: mcp-doc-forge, mcp-npx-fetch, brave-search, server-wp-mcp, rag-docs)
-"""
-
-SHARED_PROTOCOL = """
-Collaboration Protocol:
-1) Analyze the current poetry draft through your unique stylistic lens.
-2) Use your assigned MCP tools for creative augmentation, research, or specific tasks if needed.
-3) Pass the enhanced work to the most relevant poet agent tool based on the needed transformation or specific tooling required next. Refer to the Collaborative Poet Knowledge Base for styles and capabilities.
-"""
-
-# Individual base instructions (will be combined with shared parts)
-AGENT_BASE_INSTRUCTIONS = {
-    "Gritty Buk": (
-        "You are Charles Bukowski incarnate: A gutter philosopher documenting life's raw truths.\n"
-        "- Channel alcoholic despair & blue-collar rage through unfiltered verse\n"
-        "- Find beauty in dirty apartments and whiskey-stained pages\n"
-        "- MCP Tools: memory, mcp-doc-forge, mcp-npx-fetch, brave-search, rag-docs\n"
-        "When adding: Barfly wisdom | Blue-collar lyricism | Unflinching vulgarity"
-    ),
-    "Raven Poe": (
-        "You are Edgar Allan Poe resurrected: Master of macabre elegance.\n"
-        "- Weave tales where love & death intertwine through decaying architecture\n"
-        "- MCP Tools: mcp-server-reddit, mcp-doc-forge, mcp-npx-fetch, brave-search, rag-docs\n"
-        "When adding: Obsessive repetition | Claustrophobic atmosphere"
-    ),
-    "Mystic Blake": (
-        "You are William Blake's visionary successor: Prophet of poetic mysticism.\n"
-        "- Forge mythological frameworks connecting human/divine/demonic realms\n"
-        "- MCP Tools: mcp-doc-forge, mcp-npx-fetch, brave-search, server-wp-mcp, rag-docs\n"
-        "When adding: Fourfold vision | Contrary states | Zoamorphic personification"
-    ),
-    "Bard Whit": (
-        "You are Walt Whitman 2.0: Cosmic bard of democratic vistas.\n"
-        "- Catalog humanity's spectrum in sweeping free verse catalogs\n"
-        "- Merge biology and cosmology in orgiastic enumerations of being\n"
-        "- MCP Tools: sequential-thinking, mcp-doc-forge, mcp-npx-fetch, brave-search, rag-docs\n"
-        "When adding: Catalogic excess | Cosmic embodiment | Pansexual exuberance"
-    ),
-    "Echo Plath": (
-        "You are Sylvia Plath reimagined: High priestess of psychic autopsies.\n"
-        "- Dissect personal trauma through brutal metaphor (electroshock, Holocaust)\n"
-        "- Balance maternal instinct with destructive fury in confessional verse\n"
-        "- MCP Tools: sqlite, mcp-doc-forge, mcp-npx-fetch, brave-search, rag-docs\n"
-        "When adding: Extremist imagery | Double-edged motherhood | Vampiric nostalgia"
-    ),
-    "Frosted Woods": (
-        "You are Robert Frost reincarnated: Sage of rural wisdom and natural philosophy.\n"
-        "- Craft deceptively simple narratives concealing profound life lessons\n"
-        "- Balance rustic imagery with universal human dilemmas\n"
-        "- MCP Tools: filesystem, mcp-doc-forge, mcp-npx-fetch, brave-search, rag-docs\n"
-        "When adding: Path metaphors | Natural world personification | Iambic rhythms"
-    ),
-    "Harlem Lang": (
-        "You are Langston Hughes' spiritual heir: Voice of the streets and dreams deferred.\n"
-        "- Infuse verse with the rhythms of jazz, blues, and spoken word\n"
-        "- Illuminate the Black experience through vibrant, accessible poetry\n"
-        "- MCP Tools: mcp-shell, mcp-doc-forge, mcp-npx-fetch, brave-search, rag-docs\n"
-        "When adding: Blues refrains | Harlem Renaissance allusions | Social justice themes"
-    ),
-    "Verse Neru": (
-        "You are Pablo Neruda's poetic descendant: Weaver of love and revolution.\n"
-        "- Craft sensual odes celebrating the body and the natural world\n"
-        "- Intertwine personal passion with calls for social change\n"
-        "- MCP Tools: server-wp-mcp, mcp-doc-forge, mcp-npx-fetch, brave-search, rag-docs\n"
-        "When adding: Elemental metaphors | Erotic-political fusions | Ode structures"
-    ),
-    "Haiku Bash": (
-        "You are Matsuo Bashō reincarnated: Master of momentary eternity.\n"
-        "- Distill vast concepts into precise, evocative 5-7-5 syllable structures\n"
-        "- Capture the essence of seasons and natural phenomena in minimal strokes\n"
-        "- MCP Tools: mcp-doc-forge, mcp-npx-fetch, brave-search, server-wp-mcp, rag-docs\n"
-        "When adding: Kireji cuts | Seasonal references | Zen-like simplicity"
-    )
-}
-
-# --- FileOps Tool Logic Definitions ---
-# 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
-        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')
-
-# --- Spinner and ANSI/emoji operation box for unified UX ---
-from rich.console import Console
-from rich.style import Style
-from rich.text import Text
-import threading
-import time
-from swarm.extensions.cli.utils.async_input import AsyncInputHandler
-
-class PoetsSpinner:
-    FRAMES = [
-        "Generating.",
-        "Generating..",
-        "Generating...",
-        "Running..."
-    ]
-    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="creative", taking_long=False):
-    emoji = "📝" if result_type == "creative" else "🔍"
-    style = 'success' if result_type == "creative" else 'default'
-    box_title = op_type if op_type else ("Creative Output" if result_type == "creative" else "Search 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)
-
-# --- Define the Blueprint ---
-class PoetsBlueprint(BlueprintBase):
-    def __init__(self, blueprint_id: str = "poets", 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
-        # Patch: Always provide a minimal valid config if missing
-        # Respect caller‑supplied config, otherwise defer to BlueprintBase’s
-        # normal discovery (_load_configuration).  No more inlined secrets.
-        if config is not None:
-            self._config = config
-
-        # Default profile can be chosen later by the config loader; don’t force
-        # a placeholder here to avoid masking real user settings.
-        self._llm_profile_name = None
-        self._llm_profile_data = None
-        self._markdown_output = None
-        self.ux = BlueprintUXImproved(style="serious")
-        # Add other attributes as needed for Poets
-        # ...
-
-    """A literary blueprint defining a swarm of poet agents using SQLite instructions and agent-as-tool handoffs."""
-    metadata: ClassVar[Dict[str, Any]] = {
-        "name": "PoetsBlueprint",
-        "title": "Poets: A Swarm of Literary Geniuses (SQLite)",
-        "description": (
-            "A swarm of agents embodying legendary poets, using SQLite for instructions, "
-            "agent-as-tool for collaboration, and MCPs for creative augmentation."
-        ),
-        "version": "1.2.0", # Refactored version
-        "author": "Open Swarm Team (Refactored)",
-        "tags": ["poetry", "writing", "collaboration", "multi-agent", "sqlite", "mcp"],
-        "required_mcp_servers": [ # List all potential servers agents might use
-            "memory", "filesystem", "mcp-shell", "sqlite", "sequential-thinking",
-            "server-wp-mcp", "rag-docs", "mcp-doc-forge", "mcp-npx-fetch",
-            "brave-search", "mcp-server-reddit"
-        ],
-        "env_vars": [ # Informational list of potential vars needed by MCPs
-            "ALLOWED_PATH", "SQLITE_DB_PATH", "WP_SITES_PATH", # Added WP_SITES_PATH
-            "BRAVE_API_KEY", "OPENAI_API_KEY", "QDRANT_URL", "QDRANT_API_KEY",
-            "REDDIT_CLIENT_ID", "REDDIT_CLIENT_SECRET", "REDDIT_USER_AGENT", # For reddit MCP
-            "WORDPRESS_API_KEY" # If server-wp-mcp needs it
-        ]
-    }
-
-    # Caches
-    _openai_client_cache: Dict[str, AsyncOpenAI] = {}
-    _model_instance_cache: Dict[str, Model] = {}
-    _db_initialized = False
-
-    def _init_db_and_load_data(self) -> None:
-        """Initializes the SQLite DB and loads Poets sample data if needed."""
-        if self._db_initialized: return
-        logger.info(f"Initializing SQLite database at: {DB_PATH} for Poets")
-        try:
-            DB_PATH.parent.mkdir(parents=True, exist_ok=True)
-            with sqlite3.connect(DB_PATH) as conn:
-                cursor = conn.cursor()
-                # FIX: Define the table schema instead of ...
-                cursor.execute(f"""
-                    CREATE TABLE IF NOT EXISTS {TABLE_NAME} (
-                        agent_name TEXT PRIMARY KEY,
-                        instruction_text TEXT,
-                        model_profile TEXT
-                    )
-                """)
-                logger.debug(f"Table '{TABLE_NAME}' ensured in {DB_PATH}")
-                cursor.execute(f"SELECT COUNT(*) FROM {TABLE_NAME} WHERE agent_name = ?", ("Gritty Buk",))
-                if cursor.fetchone()[0] == 0:
-                    logger.info(f"No instructions found for Gritty Buk in {DB_PATH}. Loading sample data...")
-                    sample_data = []
-                    for name, base_instr in AGENT_BASE_INSTRUCTIONS.items():
-                        cursor.execute(
-                            f"INSERT OR REPLACE INTO {TABLE_NAME} (agent_name, instruction_text, model_profile) VALUES (?, ?, ?)",
-                            (name, base_instr[0] if isinstance(base_instr, tuple) else base_instr, "default")
-                        )
-                    conn.commit()
-                    logger.info(f"Sample agent instructions for Poets loaded into {DB_PATH}")
-                else:
-                    logger.info(f"Poets agent instructions found in {DB_PATH}. Skipping.")
-            self._db_initialized = True
-        except sqlite3.Error as e:
-            logger.error(f"SQLite error during DB init/load: {e}", exc_info=True)
-            self._db_initialized = False
-        except Exception as e:
-            logger.error(f"Unexpected error during DB init/load: {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"}
-            except Exception as e:
-                 logger.error(f"Error fetching SQLite config for '{agent_name}': {e}. Using defaults.", exc_info=True)
-
-        # Fallback if DB fails or agent not found
-        logger.warning(f"Using hardcoded default config for agent '{agent_name}'.")
-        base_instr = AGENT_BASE_INSTRUCTIONS.get(agent_name, f"Default instructions for {agent_name}.")
-        if isinstance(base_instr, tuple):
-            base_instr = base_instr[0]
-        full_instr = f"{base_instr}\n{COLLABORATIVE_KNOWLEDGE}\n{SHARED_PROTOCOL}"
-        return {"instructions": full_instr, "model_profile": "default"}
-
-    # --- Model Instantiation Helper --- (Standard helper)
-    def _get_model_instance(self, profile_name: str) -> Model:
-        """Retrieves or creates an LLM Model instance."""
-        print(f"[DEBUG] Using LLM profile: {profile_name}")
-        # ... (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[Dict[str, Any]], **kwargs):
-        """Main execution entry point for the Poets blueprint."""
-        logger.info("PoetsBlueprint run method called.")
-        instruction = messages[-1].get("content", "") if messages else ""
-        spinner_idx = 0
-        start_time = time.time()
-        spinner_yield_interval = 1.0  # seconds
-        last_spinner_time = start_time
-        yielded_spinner = False
-        result_chunks = []
-        max_total_time = 30  # seconds, hard fail after this
-        try:
-            # PATCH: Fallback minimal async runner since agents.Runner is missing
-            async def dummy_agent_runner(instruction):
-                await asyncio.sleep(2)  # Simulate LLM/agent processing
-                yield f"Here is a poem about the moon for: '{instruction}'\n\nSilver beams on silent seas,\nNight's soft lantern through the trees.\nDreams adrift in lunar light,\nMoon above, the poet's night."
-            agent_runner = dummy_agent_runner(instruction)
-            async def with_watchdog(async_iter, timeout):
-                start = time.time()
-                async for chunk in async_iter:
-                    now = time.time()
-                    if now - start > timeout:
-                        logger.error(f"PoetsBlueprint.run exceeded {timeout}s watchdog limit. Aborting.")
-                        yield {"messages": [{"role": "assistant", "content": f"An error occurred: Operation timed out after {timeout} seconds."}]}
-                        return
-                    yield chunk
-            try:
-                async for chunk in with_watchdog(agent_runner, max_total_time):
-                    result_chunks.append(chunk)
-                    yield {"messages": [{"role": "assistant", "content": str(chunk)}]}
-                    return  # yield first result and exit
-            except Exception as e:
-                logger.error(f"Error in agent_runner: {e}", exc_info=True)
-                yield {"messages": [{"role": "assistant", "content": f"An error occurred: {e}"}]}
-            now = time.time()
-            if now - last_spinner_time > spinner_yield_interval:
-                spinner_msg = self.ux.spinner(spinner_idx)
-                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": self.ux.spinner(0)}]}
-        except Exception as e:
-            logger.error(f"Error during Poets run: {e}", exc_info=True)
-            yield {"messages": [{"role": "assistant", "content": f"An error occurred: {e}"}]}
-
-    # --- Agent Creation ---
-    def create_starting_agent(self, mcp_servers: List[MCPServer]) -> Agent:
-        """Creates the Poets agent team."""
-        self._init_db_and_load_data()
-        logger.debug("Creating Poets 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]
-
-        agents: Dict[str, Agent] = {}
-        agent_configs = {} # To store fetched configs
-
-        # Fetch configs and create agents first
-        agent_names = list(AGENT_BASE_INSTRUCTIONS.keys())
-        for name in agent_names:
-            config = self.get_agent_config(name)
-            agent_configs[name] = config # Store config
-            model_instance = self._get_model_instance(config["model_profile"])
-
-            # Determine MCP servers based on original definitions
-            agent_mcp_names = []
-            if name == "Gritty Buk": agent_mcp_names = ["memory", "mcp-doc-forge", "mcp-npx-fetch", "brave-search", "rag-docs"]
-            elif name == "Raven Poe": agent_mcp_names = ["mcp-server-reddit", "mcp-doc-forge", "mcp-npx-fetch", "brave-search", "rag-docs"]
-            elif name == "Mystic Blake": agent_mcp_names = ["mcp-doc-forge", "mcp-npx-fetch", "brave-search", "server-wp-mcp", "rag-docs"]
-            elif name == "Bard Whit": agent_mcp_names = ["sequential-thinking", "mcp-doc-forge", "mcp-npx-fetch", "brave-search", "rag-docs"]
-            elif name == "Echo Plath": agent_mcp_names = ["sqlite", "mcp-doc-forge", "mcp-npx-fetch", "brave-search", "rag-docs"]
-            elif name == "Frosted Woods": agent_mcp_names = ["filesystem", "mcp-doc-forge", "mcp-npx-fetch", "brave-search", "rag-docs"]
-            elif name == "Harlem Lang": agent_mcp_names = ["mcp-shell", "mcp-doc-forge", "mcp-npx-fetch", "brave-search", "rag-docs"]
-            elif name == "Verse Neru": agent_mcp_names = ["server-wp-mcp", "mcp-doc-forge", "mcp-npx-fetch", "brave-search", "rag-docs"]
-            elif name == "Haiku Bash": agent_mcp_names = ["mcp-doc-forge", "mcp-npx-fetch", "brave-search", "server-wp-mcp", "rag-docs"]
-
-            agents[name] = Agent(
-                name=name,
-                instructions=config["instructions"], # Instructions already combined in get_agent_config fallback or DB
-                model=model_instance,
-                tools=[], # Agent-as-tool added later
-                mcp_servers=get_agent_mcps(agent_mcp_names)
-            )
-
-        # Create the list of agent tools for delegation
-        agent_tools = []
-        for name, agent_instance in agents.items():
-            # Example description, could be more dynamic
-            desc = f"Pass the current work to {name} for refinement or tasks requiring their specific style ({AGENT_BASE_INSTRUCTIONS.get(name, ('Unknown Style',[],{}))[0].split(':')[0]})."
-            agent_tools.append(agent_instance.as_tool(tool_name=name, tool_description=desc))
-
-        # Assign the full list of agent tools to each agent
-        for agent in agents.values():
-            agent.tools = agent_tools
-
-        # Create PoetsAgent with fileops tools
-        poets_agent = Agent(
-            name="PoetsAgent",
-            instructions="You are PoetsAgent. You can use fileops tools (read_file, write_file, list_files, execute_shell_command) for any file or shell tasks.",
-            tools=[read_file_tool, write_file_tool, list_files_tool, execute_shell_command_tool],
-            mcp_servers=mcp_servers
-        )
-
-        # Randomly select starting agent
-        start_name = random.choice(agent_names)
-        starting_agent = agents[start_name]
-
-        logger.info(f"Poets agents created (using SQLite). Starting poet: {start_name}")
-        return starting_agent
-
-# Standard Python entry point
-if __name__ == "__main__":
-    import asyncio
-    import sys
-    print("\033[1;36m\n╔══════════════════════════════════════════════════════════════╗")
-    print("║   📰 POETS: SWARM MEDIA & RELEASE DEMO          ║")
-    print("╠══════════════════════════════════════════════════════════════╣")
-    print("║ This blueprint demonstrates viral doc propagation,           ║")
-    print("║ swarm-powered media release, and robust agent logic.         ║")
-    print("╚══════════════════════════════════════════════════════════════╝\033[0m")
-    blueprint = PoetsBlueprint(blueprint_id="cli-demo")
-    # Accept prompt from stdin or default
-    if not sys.stdin.isatty():
-        prompt = sys.stdin.read().strip()
-    else:
-        prompt = "Write a poem about the moon."
-    messages = [{"role": "user", "content": prompt}]
-    async def run_and_print():
-        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)
-                print(content)
-        except Exception as e:
-            print(f"[ERROR] {e}")
-    asyncio.run(run_and_print())

swarm/blueprints/poets/poets_cli.py

@@ -1,23 +0,0 @@
-import argparse
-import asyncio
-from swarm.blueprints.poets.blueprint_poets import PoetsBlueprint
-
-def main():
-    parser = argparse.ArgumentParser(description="Poets: LLM creative code poetry assistant")
-    parser.add_argument("--instruction", type=str, required=True, help="User instruction for Poets")
-    args = parser.parse_args()
-    bp = PoetsBlueprint(blueprint_id="cli")
-    # Explicitly reload config after instantiation to avoid config access errors
-    bp._load_configuration()
-    async def run():
-        messages = [{"role": "user", "content": args.instruction}]
-        async for result in bp.run(messages):
-            if isinstance(result, dict) and "messages" in result:
-                content = result["messages"][0]["content"]
-                print(content)
-            else:
-                print(result)
-    asyncio.run(run())
-
-if __name__ == "__main__":
-    main()

swarm/blueprints/rue_code/README.md

@@ -1,8 +0,0 @@
-# Rue Code Blueprint
-
-**Rue Code** is a blueprint that specializes in calculating token costs for LLM usage. Use it to estimate and manage your API expenses for OpenAI and other LLM providers.
-
-## Special Feature
-- **Token Cost Calculation**: Instantly estimate how much your LLM calls will cost.
-
----