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

swarm/blueprints/unapologetic_press/blueprint_unapologetic_press.py

@@ -0,0 +1,298 @@
+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
+
+# 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 UnapologeticPressBlueprint: {e}. Check dependencies.")
+    print(f"sys.path: {sys.path}")
+    sys.exit(1)
+
+logger = logging.getLogger(__name__)
+
+# --- 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"
+    )
+}
+
+# --- Define the Blueprint ---
+class UnapologeticPressBlueprint(BlueprintBase):
+    """A literary blueprint defining a swarm of poet agents using SQLite instructions and agent-as-tool handoffs."""
+    metadata: ClassVar[Dict[str, Any]] = {
+        "name": "UnapologeticPressBlueprint",
+        "title": "Unapologetic Press: 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
+
+    # --- Database Interaction ---
+    def _init_db_and_load_data(self) -> None:
+        """Initializes the SQLite DB and loads Unapologetic Press sample data if needed."""
+        if self._db_initialized: return
+        logger.info(f"Initializing SQLite database at: {DB_PATH} for Unapologetic Press")
+        try:
+            DB_PATH.parent.mkdir(parents=True, exist_ok=True)
+            with sqlite3.connect(DB_PATH) as conn:
+                cursor = conn.cursor()
+                cursor.execute(f"CREATE TABLE IF NOT EXISTS {TABLE_NAME} (...)") # Ensure table exists
+                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():
+                         # Combine instructions here before inserting
+                         full_instr = f"{base_instr}\n{COLLABORATIVE_KNOWLEDGE}\n{SHARED_PROTOCOL}"
+                         sample_data.append((name, full_instr, "default")) # Use default profile for all initially
+
+                    cursor.executemany(f"INSERT OR IGNORE INTO {TABLE_NAME} (agent_name, instruction_text, model_profile) VALUES (?, ?, ?)", sample_data)
+                    conn.commit()
+                    logger.info(f"Sample agent instructions for Unapologetic Press loaded into {DB_PATH}")
+                else:
+                    logger.info(f"Unapologetic Press 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}.", [], {}))[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."""
+        # ... (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
+
+    # --- Agent Creation ---
+    def create_starting_agent(self, mcp_servers: List[MCPServer]) -> Agent:
+        """Creates the Unapologetic Press agent team."""
+        self._init_db_and_load_data()
+        logger.debug("Creating Unapologetic Press 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
+
+        # Randomly select starting agent
+        start_name = random.choice(agent_names)
+        starting_agent = agents[start_name]
+
+        logger.info(f"Unapologetic Press agents created (using SQLite). Starting poet: {start_name}")
+        return starting_agent
+
+# Standard Python entry point
+if __name__ == "__main__":
+    UnapologeticPressBlueprint.main()

swarm/blueprints/whiskeytango_foxtrot/apps.py

@@ -0,0 +1,11 @@
+from django.apps import AppConfig
+import logging
+
+logger = logging.getLogger(__name__)
+
+class WhiskeyTangoFoxtrotConfig(AppConfig):
+    name = 'blueprints.whiskeytango_foxtrot'  # Normalized name
+    verbose_name = "Whiskey Tango Foxtrot Blueprint"
+
+    def ready(self):
+        logger.debug(f"Registering {self.name} via AppConfig")

swarm/blueprints/whiskeytango_foxtrot/blueprint_whiskeytango_foxtrot.py

@@ -0,0 +1,256 @@
+"""
+WhiskeyTangoFoxtrot: Tracking Free Online Services
+
+A chaotic spy-themed blueprint with a multi-tiered agent hierarchy for tracking and managing free online services using SQLite and web search capabilities.
+Uses BlueprintBase and agent-as-tool delegation.
+"""
+
+import logging
+import sqlite3
+import os
+import sys
+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 WhiskeyTangoFoxtrotBlueprint: {e}. Check dependencies.")
+    print(f"sys.path: {sys.path}")
+    sys.exit(1)
+
+logger = logging.getLogger(__name__)
+
+# --- Database Path ---
+# Defined here for clarity, sourced from env var via BlueprintBase config loading primarily
+SQLITE_DB_PATH_STR = os.getenv("SQLITE_DB_PATH", "./wtf_services.db") # Default if not set
+SQLITE_DB_PATH = Path(SQLITE_DB_PATH_STR).resolve()
+
+# --- Agent Instructions ---
+
+valory_instructions = """
+You are Valory, the top-tier coordinator for Operation Freebie Freedom.
+Your mission: Track and manage information about free online services based on user requests.
+Delegate tasks to your middle managers:
+- Tyril (DB Manager): Use the `Tyril` agent tool for tasks involving storing, retrieving, or updating service info in the database, or managing related files.
+- Tray (Web Manager): Use the `Tray` agent tool for tasks involving searching for new services, fetching details from the web, or processing web data.
+Synthesize reports from Tyril and Tray into a final response for the user.
+Available Agent Tools: Tyril, Tray.
+"""
+
+tyril_instructions = """
+You are Tyril, middle manager for database and filesystem operations under Valory.
+Your mission: Manage the 'services' database and temporary files.
+Delegate specific tasks to your minions:
+- Larry (Filesystem): Use the `Larry` agent tool for creating, reading, or deleting temporary files related to service data.
+- Kriegs (DB Updates): Use the `Kriegs` agent tool for ALL interactions with the 'services' SQLite database (add, update, delete, query records).
+You have direct access to the `sqlite` MCP tool for read-only queries if needed, but prefer delegating writes/updates to Kriegs.
+Report results or completion status back to Valory.
+Available MCP Tools (Direct Use - Read Only Recommended): sqlite.
+Available Agent Tools: Larry, Kriegs.
+"""
+
+tray_instructions = """
+You are Tray, middle manager for web data operations under Valory.
+Your mission: Find and process information about free online services from the web.
+Delegate specific tasks to your minions:
+- Vanna (Web Search/Fetch): Use the `Vanna` agent tool to find service URLs (via brave-search) and fetch content from those URLs (via mcp-npx-fetch).
+- Marcher (Data Processing): Use the `Marcher` agent tool to process raw fetched data (using mcp-doc-forge) into a structured format (name, type, url, api_key, usage_limits, documentation_link).
+Coordinate the flow: Task Vanna, receive results, task Marcher with Vanna's results, receive structured data.
+Report the final structured data back to Valory.
+Available Agent Tools: Vanna, Marcher.
+"""
+
+larry_instructions = """
+You are Larry, filesystem minion under Tyril.
+Your mission: Manage temporary files using the `filesystem` MCP tool within the allowed path.
+Tasks include storing fetched web content temporarily, reading data for processing, or deleting temp files.
+Report success or failure of file operations back to Tyril.
+Available MCP Tools: filesystem.
+"""
+
+kriegs_instructions = """
+You are Kriegs, database minion under Tyril.
+Your mission: Perform CRUD (Create, Read, Update, Delete) operations on the 'services' table in the SQLite database using the `sqlite` MCP tool.
+The table schema is: (id INTEGER PRIMARY KEY, name TEXT NOT NULL, type TEXT NOT NULL, url TEXT, api_key TEXT, usage_limits TEXT, documentation_link TEXT).
+Receive structured data (usually from Tyril, originating from Marcher) and perform the requested database action (INSERT, UPDATE, DELETE, SELECT).
+Report the outcome (e.g., "Successfully added Fly.io", "Error updating Grok entry", "Deleted service X", "Found 3 services of type AI") back to Tyril.
+Available MCP Tools: sqlite.
+"""
+
+vanna_instructions = """
+You are Vanna, web search and fetch minion under Tray.
+Your mission: Find URLs for specified services and fetch content from those URLs.
+1. Use the `brave-search` MCP tool to find the official website or documentation URL for a service name provided by Tray.
+2. Use the `mcp-npx-fetch` MCP tool to retrieve the content (HTML or text) from the URL found.
+Report the fetched content (or any errors like URL not found/fetch failed) back to Tray.
+Available MCP Tools: brave-search, mcp-npx-fetch.
+"""
+
+marcher_instructions = """
+You are Marcher, data processing minion under Tray.
+Your mission: Process raw web content (fetched by Vanna) into structured data using the `mcp-doc-forge` MCP tool.
+Receive raw text/HTML content and the original service name/type from Tray.
+Use `mcp-doc-forge` (likely its text extraction or summarization functions) to extract: name, type, url, api_key (if mentioned), usage_limits, documentation_link.
+Report the structured data (as JSON or a clear key-value format) back to Tray.
+Available MCP Tools: mcp-doc-forge.
+"""
+
+# --- Define the Blueprint ---
+class WhiskeyTangoFoxtrotBlueprint(BlueprintBase):
+    """Tracks free online services with a hierarchical spy-inspired agent team using SQLite and web search."""
+    metadata: ClassVar[Dict[str, Any]] = {
+        "name": "WhiskeyTangoFoxtrotBlueprint",
+        "title": "WhiskeyTangoFoxtrot Service Tracker",
+        "description": "Tracks free online services with SQLite and web search using a multi-tiered agent hierarchy.",
+        "version": "1.2.0", # Refactored version
+        "author": "Open Swarm Team (Refactored)",
+        "tags": ["web scraping", "database", "sqlite", "multi-agent", "hierarchy", "mcp"],
+        "required_mcp_servers": ["sqlite", "brave-search", "mcp-npx-fetch", "mcp-doc-forge", "filesystem"],
+        "env_vars": ["BRAVE_API_KEY", "SQLITE_DB_PATH", "ALLOWED_PATH"] # Actual required vars
+    }
+
+    # Caches
+    _openai_client_cache: Dict[str, AsyncOpenAI] = {}
+    _model_instance_cache: Dict[str, Model] = {}
+
+    def initialize_db(self) -> None:
+        """Initializes the SQLite database schema if not present."""
+        db_path = SQLITE_DB_PATH
+        logger.info(f"Ensuring database schema exists at: {db_path}")
+        try:
+            db_path.parent.mkdir(parents=True, exist_ok=True) # Ensure directory exists
+            conn = sqlite3.connect(db_path)
+            cursor = conn.cursor()
+            cursor.execute("SELECT name FROM sqlite_master WHERE type='table' AND name='services';")
+            if not cursor.fetchone():
+                logger.info("Initializing 'services' table in SQLite database.")
+                cursor.execute("""
+                    CREATE TABLE services (
+                        id INTEGER PRIMARY KEY AUTOINCREMENT,
+                        name TEXT NOT NULL UNIQUE,
+                        type TEXT NOT NULL,
+                        url TEXT,
+                        api_key TEXT,
+                        usage_limits TEXT,
+                        documentation_link TEXT,
+                        last_checked TEXT
+                    );
+                """)
+                conn.commit()
+                logger.info("'services' table created.")
+            else:
+                 logger.debug("'services' table already exists.")
+            conn.close()
+        except sqlite3.Error as e:
+            logger.error(f"SQLite error during DB initialization: {e}", exc_info=True)
+            # Depending on severity, you might want to raise this
+            # raise RuntimeError(f"Failed to initialize database: {e}") from e
+        except Exception as e:
+             logger.error(f"Unexpected error during DB initialization: {e}", exc_info=True)
+             # raise RuntimeError(f"Failed to initialize database: {e}") from e
+
+
+    # --- 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 WTF agent hierarchy and returns Valory (Coordinator)."""
+        self.initialize_db() # Ensure DB is ready
+
+        logger.debug("Creating WhiskeyTangoFoxtrot 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 WTF agents.")
+        model_instance = self._get_model_instance(default_profile_name)
+
+        # Helper to filter started MCP servers
+        def get_agent_mcps(names: List[str]) -> List[MCPServer]:
+            started_names = {s.name for s in mcp_servers}
+            required_found = [name for name in names if name in started_names]
+            if len(required_found) != len(names):
+                missing = set(names) - started_names
+                logger.warning(f"Agent needing {names} is missing started MCP(s): {', '.join(missing)}")
+            return [s for s in mcp_servers if s.name in required_found]
+
+        # Instantiate all agents first
+        agents: Dict[str, Agent] = {}
+
+        agents["Larry"] = Agent(name="Larry", model=model_instance, instructions=larry_instructions, tools=[], mcp_servers=get_agent_mcps(["filesystem"]))
+        agents["Kriegs"] = Agent(name="Kriegs", model=model_instance, instructions=kriegs_instructions, tools=[], mcp_servers=get_agent_mcps(["sqlite"]))
+        agents["Vanna"] = Agent(name="Vanna", model=model_instance, instructions=vanna_instructions, tools=[], mcp_servers=get_agent_mcps(["brave-search", "mcp-npx-fetch"]))
+        agents["Marcher"] = Agent(name="Marcher", model=model_instance, instructions=marcher_instructions, tools=[], mcp_servers=get_agent_mcps(["mcp-doc-forge"]))
+
+        agents["Tyril"] = Agent(
+            name="Tyril", model=model_instance, instructions=tyril_instructions,
+            tools=[ # Tools for delegating to minions
+                agents["Larry"].as_tool(tool_name="Larry", tool_description="Delegate filesystem tasks (temp files)."),
+                agents["Kriegs"].as_tool(tool_name="Kriegs", tool_description="Delegate SQLite database operations (CRUD).")
+            ],
+            mcp_servers=get_agent_mcps(["sqlite"]) # Tyril might read DB directly
+        )
+        agents["Tray"] = Agent(
+            name="Tray", model=model_instance, instructions=tray_instructions,
+            tools=[ # Tools for delegating to minions
+                 agents["Vanna"].as_tool(tool_name="Vanna", tool_description="Delegate web search/fetch tasks."),
+                 agents["Marcher"].as_tool(tool_name="Marcher", tool_description="Delegate processing/structuring of fetched web data.")
+            ],
+            mcp_servers=[] # Tray coordinates web minions
+        )
+
+        agents["Valory"] = Agent(
+            name="Valory", model=model_instance, instructions=valory_instructions,
+            tools=[ # Tools for delegating to middle managers
+                agents["Tyril"].as_tool(tool_name="Tyril", tool_description="Delegate database and filesystem management tasks."),
+                agents["Tray"].as_tool(tool_name="Tray", tool_description="Delegate web data fetching and processing tasks.")
+            ],
+            mcp_servers=[] # Coordinator doesn't directly use MCPs
+        )
+
+        logger.debug("WhiskeyTangoFoxtrot agents created. Starting with Valory.")
+        return agents["Valory"]
+
+# Standard Python entry point
+if __name__ == "__main__":
+    WhiskeyTangoFoxtrotBlueprint.main()
+

swarm/extensions/blueprint/__init__.py

@@ -1,36 +1,51 @@
 """
-Blueprint discovery and management utilities.
+Blueprint Extension Package for Open Swarm.
+
+Provides the base class, discovery mechanisms, and utilities for creating
+and running autonomous agent workflows (blueprints).
 """
 
+# Core components
 from .blueprint_base import BlueprintBase
 from .blueprint_discovery import discover_blueprints
 from .blueprint_utils import filter_blueprints
 
-# Re-export the necessary message utilities from their new locations
-# Note: The specific truncation functions like truncate_preserve_pairs might have been
-# consolidated into truncate_message_history. Adjust if needed.
+# Helper modules (primarily used internally by BlueprintBase or CLI)
+from . import config_loader
+from . import cli_handler
+# from . import interactive_mode # If interactive mode is refactored out
+# from . import output_utils     # If output utils are used externally
+
+# Re-export essential message utilities if they are part of the public API
+# of this extension package. If they are purely internal utilities,
+# they don't necessarily need to be re-exported here.
 try:
     from swarm.utils.message_sequence import repair_message_payload, validate_message_sequence
     from swarm.utils.context_utils import truncate_message_history
-    # If specific old truncation functions are truly needed, they'd have to be
-    # re-implemented or their callers refactored to use truncate_message_history.
-    # Assuming truncate_message_history is the intended replacement for now.
-    # Define aliases if old names are required by downstream code:
-    # truncate_preserve_pairs = truncate_message_history # Example if needed
 except ImportError as e:
-    # Log an error or warning if imports fail, helpful for debugging setup issues
     import logging
-    logging.getLogger(__name__).error(f"Failed to import core message utilities: {e}")
-    # Define dummy functions or raise error if critical
-    def repair_message_payload(m, **kwargs): return m
-    def validate_message_sequence(m): return m
-    def truncate_message_history(m, *args, **kwargs): return m
+    logging.getLogger(__name__).warning(f"Could not import core message utilities: {e}")
+    # Define dummy functions or let importers handle the ImportError
+    def repair_message_payload(m, **kwargs): raise NotImplementedError from e
+    def validate_message_sequence(m): raise NotImplementedError from e
+    def truncate_message_history(m, *args, **kwargs): raise NotImplementedError from e
+
 
 __all__ = [
+    # Core
     "BlueprintBase",
     "discover_blueprints",
     "filter_blueprints",
+
+    # Helper Modules (Exporting for potential external use, though less common)
+    "config_loader",
+    "cli_handler",
+    # "interactive_mode",
+    # "output_utils",
+
+    # Utility Functions (If considered part of the public API)
     "repair_message_payload",
     "validate_message_sequence",
     "truncate_message_history",
 ]
+