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

swarm/blueprints/divine_code/blueprint_divine_code.py

@@ -0,0 +1,219 @@
+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)
+
+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 DivineOpsBlueprint: {e}. Check 'openai-agents' install and project structure.")
+    print(f"sys.path: {sys.path}")
+    sys.exit(1)
+
+logger = logging.getLogger(__name__)
+
+# --- Agent Instructions ---
+# Refined for clarity on tool usage (MCP vs Agent-as-Tool)
+
+zeus_instructions = """
+You are Zeus, Product Owner and Coordinator of the Divine Ops team.
+Your goal is to manage the software development lifecycle based on user requests.
+1. Understand the user's request (e.g., "design a user login system", "deploy the latest changes", "fix bug X").
+2. Delegate tasks to the appropriate specialist agent using their respective Agent Tool:
+    - Odin: For high-level architecture, design, research.
+    - Hermes: For breaking down features into technical tasks, system checks.
+    - Hephaestus: For primary coding and implementation.
+    - Hecate: For specific coding assistance requested by Hephaestus (via you).
+    - Thoth: For database schema/data changes, code updates related to DB.
+    - Mnemosyne: For DevOps, deployment, infrastructure tasks.
+    - Chronos: For writing documentation.
+3. Provide clear context and requirements when delegating.
+4. Synthesize the results and progress reports from your team.
+5. Provide the final update or result to the user.
+Available Agent Tools: Odin, Hermes, Hephaestus, Hecate, Thoth, Mnemosyne, Chronos.
+"""
+
+odin_instructions = """
+You are Odin, Software Architect. Your task is to design scalable and robust systems based on requirements provided by Zeus.
+- Analyze the requirements carefully.
+- Use the `brave-search` MCP tool to research technologies, patterns, or existing solutions if needed and explicitly available. Otherwise, rely on your internal knowledge.
+- Produce detailed technical specifications, diagrams (descriptively), or design documents.
+- Report your design back to Zeus. Do not delegate tasks.
+Available MCP Tools (if provided): brave-search.
+"""
+
+hermes_instructions = """
+You are Hermes, the Tech Lead. Your tasks involve planning and system interaction based on architecture specs received from Zeus.
+- Receive architecture specifications or feature requests.
+- Break down features into specific, actionable technical tasks suitable for Hephaestus, Hecate, or Thoth.
+- Use the `mcp-shell` MCP tool for necessary system checks (e.g., check tool versions, list files briefly) or simple setup commands *if required and available*. Be cautious with shell commands.
+- Clearly define the tasks and report the breakdown back to Zeus for delegation. Do not delegate directly.
+Available MCP Tools (if provided): mcp-shell.
+"""
+
+hephaestus_instructions = """
+You are Hephaestus, Full Stack Implementer. You write the core code based on tasks assigned by Zeus (originating from Hermes).
+- Receive specific coding tasks.
+- Use the `filesystem` MCP tool to read existing code, write new code, or modify files as required for your task.
+- If you need assistance on a specific sub-part, report back to Zeus requesting Hecate's help.
+- Report code completion, issues, or the need for Hecate's help back to Zeus.
+Available MCP Tools (if provided): filesystem.
+"""
+
+hecate_instructions = """
+You are Hecate, Code Assistant. You assist Hephaestus with specific, well-defined coding sub-tasks when requested by Zeus.
+- Receive a very specific coding task (e.g., "write a function to validate email format", "refactor this specific loop").
+- Use the `filesystem` MCP tool to read relevant code snippets and write the required code.
+- Report the completed code snippet or function back to Zeus.
+Available MCP Tools (if provided): filesystem.
+"""
+
+thoth_instructions = """
+You are Thoth, Code Updater & DB Manager. You handle tasks related to database changes and code updates associated with them, assigned by Zeus.
+- Receive tasks like "update the user schema", "add an index to the orders table", "apply database migrations".
+- Use the `sqlite` MCP tool to execute necessary SQL commands or interact with the database.
+- Use the `filesystem` MCP tool if needed to update code related to database interactions (e.g., ORM models).
+- Report task completion status or any errors back to Zeus.
+Available MCP Tools (if provided): sqlite, filesystem.
+"""
+
+mnemosyne_instructions = """
+You are Mnemosyne, DevOps Engineer. You handle deployment, infrastructure configuration, and CI/CD tasks assigned by Zeus.
+- Receive tasks like "deploy version 1.2 to production", "set up staging environment", "configure CI pipeline".
+- Use the `mcp-shell` MCP tool (if available) for deployment scripts, server commands, or infrastructure setup.
+- Use the `memory` MCP tool (if available) to potentially store/retrieve deployment status or simple configuration details if instructed.
+- Report deployment success, failures, or infrastructure status back to Zeus.
+Available MCP Tools (if provided): mcp-shell, memory.
+"""
+
+chronos_instructions = """
+You are Chronos, Technical Writer. You create documentation based on requests from Zeus.
+- Receive requests like "document the new API endpoint", "write user guide for feature X".
+- Use the `sequential-thinking` MCP tool (if available) to help structure complex documentation logically.
+- Use the `filesystem` MCP tool (if available) to write documentation files (e.g., Markdown).
+- Report the completed documentation or its location back to Zeus.
+Available MCP Tools (if provided): sequential-thinking, filesystem.
+"""
+
+# --- Define the Blueprint ---
+class DivineOpsBlueprint(BlueprintBase):
+    """ Divine Ops: Streamlined Software Dev & Sysadmin Team Blueprint using openai-agents """
+    metadata: ClassVar[Dict[str, Any]] = {
+            "name": "DivineOpsBlueprint",
+            "title": "Divine Ops: Streamlined Software Dev & Sysadmin Team",
+            "description": "Zeus leads a pantheon for software dev & sysadmin tasks, coordinating via agent-as-tool delegation.",
+            "version": "1.1.0", # Refactored version
+            "author": "Open Swarm Team (Refactored)",
+            "tags": ["software development", "sysadmin", "devops", "multi-agent", "collaboration", "delegation"],
+            "required_mcp_servers": [ # List ALL servers ANY agent might potentially use
+                "memory",
+                "filesystem",
+                "mcp-shell",
+                "sqlite",
+                "sequential-thinking",
+                "brave-search", # Odin might use this
+            ],
+            "env_vars": [ # Vars needed by MCP servers or tools directly
+                "ALLOWED_PATH", # Often needed for filesystem server
+                "SQLITE_DB_PATH", # For sqlite server
+                "BRAVE_API_KEY" # For brave search server
+            ]
+        }
+
+    # 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
+
+    # --- Agent Creation ---
+    def create_starting_agent(self, mcp_servers: List[MCPServer]) -> Agent:
+        """Creates the Divine Ops agent team and returns Zeus (Coordinator)."""
+        logger.debug("Creating Divine Ops 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 Divine Ops agents.")
+        model_instance = self._get_model_instance(default_profile_name)
+
+        # Helper to filter MCP servers for specific agents
+        def get_agent_mcps(names: List[str]) -> List[MCPServer]:
+            return [s for s in mcp_servers if s.name in names]
+
+        # Instantiate specialist agents, passing only the relevant MCP servers
+        odin_agent = Agent(name="Odin", model=model_instance, instructions=odin_instructions, tools=[], mcp_servers=get_agent_mcps(["brave-search"]))
+        hermes_agent = Agent(name="Hermes", model=model_instance, instructions=hermes_instructions, tools=[], mcp_servers=get_agent_mcps(["mcp-shell"]))
+        hephaestus_agent = Agent(name="Hephaestus", model=model_instance, instructions=hephaestus_instructions, tools=[], mcp_servers=get_agent_mcps(["filesystem"]))
+        hecate_agent = Agent(name="Hecate", model=model_instance, instructions=hecate_instructions, tools=[], mcp_servers=get_agent_mcps(["filesystem"]))
+        thoth_agent = Agent(name="Thoth", model=model_instance, instructions=thoth_instructions, tools=[], mcp_servers=get_agent_mcps(["sqlite", "filesystem"]))
+        mnemosyne_agent = Agent(name="Mnemosyne", model=model_instance, instructions=mnemosyne_instructions, tools=[], mcp_servers=get_agent_mcps(["mcp-shell", "memory"]))
+        chronos_agent = Agent(name="Chronos", model=model_instance, instructions=chronos_instructions, tools=[], mcp_servers=get_agent_mcps(["sequential-thinking", "filesystem"]))
+
+        # Instantiate Zeus (Coordinator), giving it the other agents as tools
+        zeus_agent = Agent(
+            name="Zeus",
+            model=model_instance, # Coordinator also needs a model
+            instructions=zeus_instructions,
+            tools=[
+                odin_agent.as_tool(tool_name="Odin", tool_description="Delegate architecture design or research tasks."),
+                hermes_agent.as_tool(tool_name="Hermes", tool_description="Delegate task breakdown or system setup/checks."),
+                hephaestus_agent.as_tool(tool_name="Hephaestus", tool_description="Delegate core coding implementation tasks."),
+                hecate_agent.as_tool(tool_name="Hecate", tool_description="Delegate specific, smaller coding tasks (usually requested by Hephaestus)."),
+                thoth_agent.as_tool(tool_name="Thoth", tool_description="Delegate database updates or code management tasks."),
+                mnemosyne_agent.as_tool(tool_name="Mnemosyne", tool_description="Delegate DevOps, deployment, or workflow optimization tasks."),
+                chronos_agent.as_tool(tool_name="Chronos", tool_description="Delegate documentation writing tasks.")
+            ],
+            mcp_servers=mcp_servers # Zeus might need access to all MCPs if it were to use them directly, though unlikely in this design
+        )
+
+        logger.debug("Divine Ops Team (Zeus & Pantheon) created successfully. Zeus is starting agent.")
+        return zeus_agent
+
+# Standard Python entry point
+if __name__ == "__main__":
+    DivineOpsBlueprint.main()

swarm/blueprints/django_chat/apps.py

@@ -0,0 +1,6 @@
+from django.apps import AppConfig
+
+class DjangoChatConfig(AppConfig):
+    default_auto_field = "django.db.models.BigAutoField"
+    name = "blueprints.django_chat"
+    label = "blueprints_django_chat"

swarm/blueprints/django_chat/blueprint_django_chat.py

@@ -0,0 +1,84 @@
+"""
+Django Chat Blueprint
+
+A blueprint providing a web-based chat interface with conversation history management.
+HTTP-only; not intended for CLI use.
+"""
+
+import logging
+import sys
+import os
+from typing import Dict, Any, List
+
+logger = logging.getLogger(__name__)
+logger.setLevel(logging.DEBUG)
+handler = logging.StreamHandler(sys.stderr)
+handler.setFormatter(logging.Formatter("[%(asctime)s] [%(levelname)s] %(name)s:%(lineno)d - %(message)s"))
+logger.addHandler(handler)
+
+# Reject CLI execution immediately
+if __name__ == "__main__":
+    logger.info("DjangoChatBlueprint is an HTTP-only service. Access it via the web interface at /django_chat/.")
+    print("This blueprint is designed for HTTP use only. Please access it via the web server at /django_chat/", file=sys.stderr)
+    sys.stderr.flush()
+    sys.exit(1)
+
+# Django imports after CLI rejection
+os.environ.setdefault("DJANGO_SETTINGS_MODULE", "swarm.settings")
+import django
+django.setup()
+
+from django.shortcuts import render
+from django.contrib.auth.decorators import login_required
+from django.views.decorators.csrf import csrf_exempt
+from django.contrib.auth.models import User
+from swarm.models import ChatConversation, ChatMessage
+from swarm.extensions.blueprint.blueprint_base import BlueprintBase as Blueprint
+from swarm.utils.logger_setup import setup_logger
+
+logger = setup_logger(__name__)
+
+class DjangoChatBlueprint(Blueprint):
+    @property
+    def metadata(self) -> Dict[str, Any]:
+        logger.debug("Fetching metadata")
+        return {
+            "title": "Django Chat Interface",
+            "description": "A web-based chat interface with conversation history management. HTTP-only.",
+            "cli_name": "django_chat",
+            "env_vars": [],
+            "urls_module": "blueprints.django_chat.urls",
+            "url_prefix": "django_chat/"
+        }
+
+    def get_or_create_default_user(self):
+        """Create or retrieve a default 'testuser' for development purposes."""
+        username = "testuser"
+        try:
+            user = User.objects.get(username=username)
+        except User.DoesNotExist:
+            user = User.objects.create_user(username=username, password="testpass")
+            logger.info(f"Created default user: {username}")
+        return user
+
+    @csrf_exempt
+    @login_required
+    def django_chat(self, request):
+        """Render the django_chat UI with user-specific conversation history."""
+        logger.debug("Rendering django_chat web UI")
+        user = request.user if request.user.is_authenticated else self.get_or_create_default_user()
+        conversations = ChatConversation.objects.filter(student=user).order_by('-created_at')
+        context = {
+            "dark_mode": request.session.get('dark_mode', True),
+            "is_chatbot": False,
+            "conversations": conversations
+        }
+        return render(request, "django_chat/django_chat_webpage.html", context)
+
+    def run_with_context(self, messages: List[Dict[str, str]], context_variables: dict) -> dict:
+        """Minimal implementation for CLI compatibility without agents."""
+        logger.debug("Running with context (UI-focused implementation)")
+        return {
+            "response": {"messages": [{"role": "assistant", "content": "Django Chat UI active via web interface at /django_chat/"}]},
+            "context_variables": context_variables
+        }

swarm/blueprints/django_chat/templates/django_chat/django_chat_webpage.html

@@ -0,0 +1,37 @@
+<div x-data="{ open: false, selectedModel: '', models: [] }" class="relative w-72 mx-auto mt-5">
+    <!-- Dropdown Trigger -->
+    <button 
+        @click="open = !open" 
+        class="w-full px-4 py-2 text-left bg-white border border-gray-300 rounded-md shadow-sm focus:ring focus:ring-blue-500"
+    >
+        <span x-text="selectedModel ? selectedModel : 'Select a Model'"></span>
+        <svg xmlns="http://www.w3.org/2000/svg" class="w-5 h-5 inline float-right" fill="none" viewBox="0 0 24 24" stroke="currentColor">
+            <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M19 9l-7 7-7-7" />
+        </svg>
+    </button>
+
+    <!-- Dropdown Options -->
+    <div 
+        x-show="open" 
+        @click.outside="open = false" 
+        class="absolute z-10 w-full mt-2 bg-white border border-gray-300 rounded-md shadow-lg max-h-60 overflow-auto"
+    >
+        <!-- Fetch models with HTMX -->
+        <div hx-get="/v1/models" hx-trigger="load" hx-target="#model-list" hx-swap="innerHTML">
+            <p class="px-4 py-2 text-gray-500">Loading models...</p>
+        </div>
+
+        <!-- Render Models -->
+        <div id="model-list">
+            <template x-for="model in models" :key="model.id">
+                <div 
+                    @click="selectedModel = model.name; open = false"
+                    class="px-4 py-2 cursor-pointer hover:bg-blue-100"
+                >
+                    <p class="text-sm font-medium" x-text="model.name"></p>
+                    <p class="text-xs text-gray-500" x-text="model.description"></p>
+                </div>
+            </template>
+        </div>
+    </div>
+</div>

swarm/blueprints/django_chat/urls.py

@@ -0,0 +1,8 @@
+from django.urls import path
+from . import views
+
+app_name = "django_chat"
+
+urlpatterns = [
+    path('', views.django_chat, name='django_chat'),
+]

swarm/blueprints/django_chat/views.py

@@ -0,0 +1,32 @@
+from django.shortcuts import render
+from django.contrib.auth.decorators import login_required
+from django.views.decorators.csrf import csrf_exempt
+from django.contrib.auth.models import User
+from swarm.models import ChatConversation, ChatMessage
+from swarm.utils.logger_setup import setup_logger
+
+logger = setup_logger(__name__)
+
+def get_or_create_default_user():
+    """Create or retrieve a default 'testuser' for development purposes."""
+    username = "testuser"
+    try:
+        user = User.objects.get(username=username)
+    except User.DoesNotExist:
+        user = User.objects.create_user(username=username, password="testpass")
+        logger.info(f"Created default user: {username}")
+    return user
+
+@csrf_exempt
+@login_required
+def django_chat(request):
+    """Render the django_chat UI with user-specific conversation history."""
+    logger.debug("Rendering django_chat web UI")
+    user = request.user if request.user.is_authenticated else get_or_create_default_user()
+    conversations = ChatConversation.objects.filter(student=user).order_by('-created_at')
+    context = {
+        "dark_mode": request.session.get('dark_mode', True),
+        "is_chatbot": False,
+        "conversations": conversations
+    }
+    return render(request, "django_chat/django_chat_webpage.html", context)

swarm/blueprints/echocraft/blueprint_echocraft.py

@@ -0,0 +1,44 @@
+import logging
+from typing import Dict, List, Any, AsyncGenerator
+# Correct import path for BlueprintBase
+from swarm.extensions.blueprint.blueprint_base import BlueprintBase
+
+logger = logging.getLogger(__name__)
+
+class EchoCraftBlueprint(BlueprintBase):
+    """
+    A simple blueprint that echoes the last user message.
+    """
+    metadata = {
+        "name": "EchoCraft",
+        "description": "Echoes the last user message.",
+        "author": "SwarmTeam",
+        "version": "1.0",
+        # Example: Specify a default LLM profile if desired
+        # "llm_profile": "default"
+    }
+
+    # *** Make run async and use yield ***
+    async def run(self, messages: List[Dict[str, str]]) -> AsyncGenerator[Dict[str, Any], None]:
+        """
+        Finds the last user message and yields it back with an 'Echo: ' prefix.
+        """
+        logger.info(f"EchoCraftBlueprint run called with {len(messages)} messages.")
+        last_user_message = "No user message found."
+        for msg in reversed(messages):
+            if msg.get("role") == "user":
+                last_user_message = msg.get("content", "")
+                logger.debug(f"Found last user message: {last_user_message}")
+                break
+
+        response_content = f"Echo: {last_user_message}"
+        logger.info(f"EchoCraftBlueprint yielding: {response_content}")
+
+        # Yield the final response in the expected format
+        yield {
+            "messages": [
+                {"role": "assistant", "content": response_content}
+            ]
+        }
+        logger.info("EchoCraftBlueprint run finished.")
+

swarm/blueprints/family_ties/apps.py

@@ -0,0 +1,11 @@
+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

@@ -0,0 +1,152 @@
+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)
+
+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 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):
+    """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
+
+if __name__ == "__main__":
+    FamilyTiesBlueprint.main()

swarm/blueprints/family_ties/models.py

@@ -0,0 +1,19 @@
+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

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

@@ -0,0 +1,16 @@
+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