open-swarm 0.1.1745125904__py3-none-any.whl → 0.1.1745125927__py3-none-any.whl

{open_swarm-0.1.1745125904.dist-info → open_swarm-0.1.1745125927.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: open-swarm
-Version: 0.1.1745125904
+Version: 0.1.1745125927
 Summary: Open Swarm: Orchestrating AI Agent Swarms with Django
 Project-URL: Homepage, https://github.com/yourusername/open-swarm
 Project-URL: Documentation, https://github.com/yourusername/open-swarm/blob/main/README.md

{open_swarm-0.1.1745125904.dist-info → open_swarm-0.1.1745125927.dist-info}/RECORD

@@ -32,13 +32,6 @@ swarm/blueprints/django_chat/urls.py,sha256=TTTF3pgymvCYbuxpwi4WRBPv8ftQNH4pEoUR
 swarm/blueprints/django_chat/views.py,sha256=MUKjXXjXsq8jMZtAb4RR9g2mEYrwFemN6Bqxpeyi7p4,1299
 swarm/blueprints/django_chat/templates/django_chat/django_chat_webpage.html,sha256=wAEOI4Wg0JJ8drXaOcr2Pel6lW3JSHmyIpbocLS5tI8,1649
 swarm/blueprints/echocraft/blueprint_echocraft.py,sha256=9XNyuMZIBrm9kpnv1aq_W3h-9Zr2dVdzchI2uFXslg0,10988
-swarm/blueprints/family_ties/apps.py,sha256=EjV7AxDNsLM4gsLr_qMEiLAVbERuo1ZsdU9vPtOEYAY,287
-swarm/blueprints/family_ties/blueprint_family_ties.py,sha256=AkYz9_O7QSBhoZAG1jaFlTXEouL1eUfa0y6hw9MqSro,9762
-swarm/blueprints/family_ties/models.py,sha256=C3_okdVVYuu9xOpoKRsaLoGrM2775cS_cU4UKYAkJ9s,903
-swarm/blueprints/family_ties/serializers.py,sha256=kH3T6OgXjF534bO3gfAUr6GpXZ5Jx0BQkK58nvuEcqA,325
-swarm/blueprints/family_ties/settings.py,sha256=5zcVsq7ny3GLWcJnOplZW4fMFNtyC3ba0ZOESRD2gh4,425
-swarm/blueprints/family_ties/urls.py,sha256=awRZHb1gb1p3I6YZzfKMGSydd6kYPTLgax2jZ1ocS4U,294
-swarm/blueprints/family_ties/views.py,sha256=FbPkDNlFEixtRFbSpkr51IyJ28FRkXa1W5xyO_KeXH0,1081
 swarm/blueprints/flock/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 swarm/blueprints/geese/blueprint_geese.py,sha256=uP0gPHFACI18a_cY5f89ndqccNrK3YxjQPgA85T8Cms,9339
 swarm/blueprints/mcp_demo/blueprint_mcp_demo.py,sha256=bTHupSUdg9OzaRoTu9obGsxk48f9o3wUCLqVWeWYW-w,17695
@@ -51,7 +44,6 @@ swarm/blueprints/poets/blueprint_poets.py,sha256=_yWU2ujGQw_Q6ZVXX8yW7GKOFkKNyf6
 swarm/blueprints/rue_code/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 swarm/blueprints/rue_code/blueprint_rue_code.py,sha256=odxqvAIzSESlm9eecZNz-JBsjeoRpFgCZs-7tG1ZkLQ,13273
 swarm/blueprints/suggestion/blueprint_suggestion.py,sha256=Qm5YbP19SETFtXc-gTsmGUh71US7huUyKZKqtRv-Qeg,10846
-swarm/blueprints/unapologetic_press/blueprint_unapologetic_press.py,sha256=lIq6oGQlVtI8sxCq9DKmpLaHpHv-8_NJ5XHB7TEL_dg,22399
 swarm/blueprints/whiskeytango_foxtrot/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 swarm/blueprints/whiskeytango_foxtrot/apps.py,sha256=V1QKvyb2Vz-EtDNhhNe4tw2W9LYhNDuiaIq_fAU4ilw,334
 swarm/blueprints/whiskeytango_foxtrot/blueprint_whiskeytango_foxtrot.py,sha256=y5OUPe5-W0Bhm3nO0hBH31ucXuote3PBVgb0WeOQodE,16567
@@ -279,8 +271,8 @@ swarm/views/message_views.py,sha256=sDUnXyqKXC8WwIIMAlWf00s2_a2T9c75Na5FvYMJwBM,
 swarm/views/model_views.py,sha256=aAbU4AZmrOTaPeKMWtoKK7FPYHdaN3Zbx55JfKzYTRY,2937
 swarm/views/utils.py,sha256=8Usc0g0L0NPegNAyY20tJBNBy-JLwODf4VmxV0yUtpw,3627
 swarm/views/web_views.py,sha256=T1CKe-Nyv1C8aDt6QFTGWo_dkH7ojWAvS_QW9mZnZp0,7371
-open_swarm-0.1.1745125904.dist-info/METADATA,sha256=q8jtZKzgtpfD5DLbBjdCbEdzi3jwsKfx3Nn-WwJfJV8,26977
-open_swarm-0.1.1745125904.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-open_swarm-0.1.1745125904.dist-info/entry_points.txt,sha256=fo28d0_zJrytRsh8QqkdlWQT_9lyAwYUx1WuSTDI3HM,177
-open_swarm-0.1.1745125904.dist-info/licenses/LICENSE,sha256=BU9bwRlnOt_JDIb6OT55Q4leLZx9RArDLTFnlDIrBEI,1062
-open_swarm-0.1.1745125904.dist-info/RECORD,,
+open_swarm-0.1.1745125927.dist-info/METADATA,sha256=AjVBunlRv-LH1Al4Uq4n8OAcX0z_cwCsF31SqMCqoN0,26977
+open_swarm-0.1.1745125927.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+open_swarm-0.1.1745125927.dist-info/entry_points.txt,sha256=fo28d0_zJrytRsh8QqkdlWQT_9lyAwYUx1WuSTDI3HM,177
+open_swarm-0.1.1745125927.dist-info/licenses/LICENSE,sha256=BU9bwRlnOt_JDIb6OT55Q4leLZx9RArDLTFnlDIrBEI,1062
+open_swarm-0.1.1745125927.dist-info/RECORD,,

swarm/blueprints/family_ties/apps.py

@@ -1,11 +0,0 @@
-from django.apps import AppConfig
-import logging
-
-logger = logging.getLogger(__name__)
-
-class FamilyTiesConfig(AppConfig):
-    name = 'blueprints.family_ties'
-    verbose_name = "Family Ties Blueprint"
-
-    def ready(self):
-        logger.debug(f"Registering {self.name} via AppConfig")

swarm/blueprints/family_ties/blueprint_family_ties.py

@@ -1,189 +0,0 @@
-import logging
-import os
-import sys
-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)
-
-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 FamilyTiesBlueprint: {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 FamilyTiesBlueprint(BlueprintBase):
-    def __init__(self, blueprint_id: str, config_path: Optional[Path] = None, **kwargs):
-        super().__init__(blueprint_id, config_path=config_path, **kwargs)
-
-    """Manages WordPress content with a Peter/Brian agent team using the `server-wp-mcp` server."""
-    metadata: ClassVar[Dict[str, Any]] = {
-        "name": "FamilyTiesBlueprint", # Standardized name
-        "title": "Family Ties / ChaosCrew WP Manager",
-        "description": "Manages WordPress content using Peter (coordinator) and Brian (WP manager via MCP).",
-        "version": "1.2.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."""
-        # ... (Implementation is the same as in previous refactors) ...
-        if profile_name in self._model_instance_cache:
-            logger.debug(f"Using cached Model instance for profile '{profile_name}'.")
-            return self._model_instance_cache[profile_name]
-        logger.debug(f"Creating new Model instance for profile '{profile_name}'.")
-        profile_data = self.get_llm_profile(profile_name)
-        if not profile_data:
-             logger.critical(f"LLM profile '{profile_name}' (or 'default') not found.")
-             raise ValueError(f"Missing LLM profile configuration for '{profile_name}' or 'default'.")
-        provider = profile_data.get("provider", "openai").lower()
-        model_name = profile_data.get("model")
-        if not model_name:
-             logger.critical(f"LLM profile '{profile_name}' missing 'model' key.")
-             raise ValueError(f"Missing 'model' key in LLM profile '{profile_name}'.")
-        if provider != "openai":
-            logger.error(f"Unsupported LLM provider '{provider}'.")
-            raise ValueError(f"Unsupported LLM provider: {provider}")
-        client_cache_key = f"{provider}_{profile_data.get('base_url')}"
-        if client_cache_key not in self._openai_client_cache:
-             client_kwargs = { "api_key": profile_data.get("api_key"), "base_url": profile_data.get("base_url") }
-             filtered_kwargs = {k: v for k, v in client_kwargs.items() if v is not None}
-             log_kwargs = {k:v for k,v in filtered_kwargs.items() if k != 'api_key'}
-             logger.debug(f"Creating new AsyncOpenAI client for '{profile_name}': {log_kwargs}")
-             try: self._openai_client_cache[client_cache_key] = AsyncOpenAI(**filtered_kwargs)
-             except Exception as e: raise ValueError(f"Failed to init OpenAI client: {e}") from e
-        client = self._openai_client_cache[client_cache_key]
-        logger.debug(f"Instantiating OpenAIChatCompletionsModel(model='{model_name}') for '{profile_name}'.")
-        try:
-            model_instance = OpenAIChatCompletionsModel(model=model_name, openai_client=client)
-            self._model_instance_cache[profile_name] = model_instance
-            return model_instance
-        except Exception as e: raise ValueError(f"Failed to init LLM provider: {e}") from e
-
-    def create_starting_agent(self, mcp_servers: List[MCPServer]) -> Agent:
-        """Creates the Family Ties agent team and returns PeterGrifton (Coordinator)."""
-        logger.debug("Creating Family Ties 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 Family Ties agents.")
-        model_instance = self._get_model_instance(default_profile_name)
-
-        # Filter for the required MCP server
-        wp_mcp_server = next((s for s in mcp_servers if s.name == "server-wp-mcp"), None)
-        if not wp_mcp_server:
-             # This case should be prevented by BlueprintBase MCP check, but good practice
-             logger.error("Required MCP server 'server-wp-mcp' not found/started. Brian will be non-functional.")
-             # Optionally raise an error or allow degraded functionality
-             # raise ValueError("Critical MCP server 'server-wp-mcp' failed to start.")
-
-        # Instantiate Brian, passing the specific MCP server
-        brian_agent = Agent(
-            name="BrianGrifton",
-            model=model_instance,
-            instructions=brian_instructions,
-            tools=[], # Brian uses MCP tools provided by the server
-            mcp_servers=[wp_mcp_server] if wp_mcp_server else []
-        )
-
-        # Instantiate Peter, giving Brian as a tool
-        peter_agent = Agent(
-            name="PeterGrifton",
-            model=model_instance,
-            instructions=peter_instructions,
-            tools=[
-                brian_agent.as_tool(
-                    tool_name="BrianGrifton",
-                    tool_description="Delegate WordPress tasks (create/edit/list posts/sites, etc.) to Brian."
-                )
-            ],
-            mcp_servers=[] # Peter doesn't directly use MCPs
-        )
-        logger.debug("Agents created: PeterGrifton (Coordinator), BrianGrifton (WordPress Manager).")
-        return peter_agent # Peter is the entry point
-
-    async def run(self, messages: List[Dict[str, Any]], **kwargs) -> Any:
-        """Main execution entry point for the FamilyTies blueprint."""
-        logger.info("FamilyTiesBlueprint 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("FamilyTiesBlueprint run method finished.")
-
-    async def _run_non_interactive(self, instruction: str, **kwargs) -> Any:
-        logger.info(f"Running FamilyTies 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}"}]}
-
-if __name__ == "__main__":
-    import asyncio
-    import json
-    messages = [
-        {"role": "user", "content": "Who are my relatives?"}
-    ]
-    blueprint = FamilyTiesBlueprint(blueprint_id="demo-1")
-    async def run_and_print():
-        async for response in blueprint.run(messages):
-            print(json.dumps(response, indent=2))
-    asyncio.run(run_and_print())

swarm/blueprints/family_ties/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/family_ties/serializers.py

@@ -1,7 +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']

swarm/blueprints/family_ties/settings.py

@@ -1,16 +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)
-
-CORS_ALLOW_ALL_ORIGINS = True

swarm/blueprints/family_ties/urls.py

@@ -1,10 +0,0 @@
-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/family_ties/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/unapologetic_press/blueprint_unapologetic_press.py

@@ -1,397 +0,0 @@
-"""
-UnapologeticPress 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
-
-# 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 UnapologeticPressBlueprint: {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:
-    import subprocess
-    try:
-        result = subprocess.run(command, shell=True, capture_output=True, text=True)
-        return result.stdout + result.stderr
-    except Exception as e:
-        return f"ERROR: {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 ---
-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
-
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-        class DummyLLM:
-            def chat_completion_stream(self, messages, **_):
-                class DummyStream:
-                    def __aiter__(self): return self
-                    async def __anext__(self):
-                        raise StopAsyncIteration
-                return DummyStream()
-        self.llm = DummyLLM()
-
-    # --- 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
-
-    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) -> object:
-        last_user_message = next((m['content'] for m in reversed(messages) if m['role'] == 'user'), None)
-        if not last_user_message:
-            yield {"messages": [{"role": "assistant", "content": "I need a user message to proceed."}]}
-            return
-        prompt_context = {
-            "user_request": last_user_message,
-            "history": messages[:-1],
-            "available_tools": ["unapologetic_press"]
-        }
-        rendered_prompt = self.render_prompt("unapologetic_press_prompt.j2", prompt_context)
-        yield {
-            "messages": [
-                {
-                    "role": "assistant",
-                    "content": f"[UnapologeticPress LLM] Would respond to: {rendered_prompt}"
-                }
-            ]
-        }
-        return
-
-    # --- 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
-
-        # Create UnapologeticPressAgent with fileops tools
-        unapologetic_press_agent = Agent(
-            name="UnapologeticPressAgent",
-            instructions="You are UnapologeticPressAgent. 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"Unapologetic Press agents created (using SQLite). Starting poet: {start_name}")
-        return starting_agent
-
-# Standard Python entry point
-if __name__ == "__main__":
-    import asyncio
-    import json
-    print("\033[1;36m\n╔══════════════════════════════════════════════════════════════╗\n║   📰 UNAPOLOGETIC PRESS: SWARM MEDIA & RELEASE DEMO          ║\n╠══════════════════════════════════════════════════════════════╣\n║ This blueprint demonstrates viral doc propagation,           ║\n║ swarm-powered media release, and robust agent logic.         ║\n║ Try running: python blueprint_unapologetic_press.py          ║\n╚══════════════════════════════════════════════════════════════╝\033[0m")
-    messages = [
-        {"role": "user", "content": "Show me how Unapologetic Press handles media releases and swarm logic."}
-    ]
-    blueprint = UnapologeticPressBlueprint(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())