open-swarm 0.1.1744936125__py3-none-any.whl → 0.1.1744936173__py3-none-any.whl

{open_swarm-0.1.1744936125.dist-info → open_swarm-0.1.1744936173.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: open-swarm
-Version: 0.1.1744936125
+Version: 0.1.1744936173
 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.1744936125.dist-info → open_swarm-0.1.1744936173.dist-info}/RECORD

@@ -14,11 +14,9 @@ swarm/util.py,sha256=G4x2hXopHhB7IdGCkUXGoykYWyiICnjxg7wcr-WqL8I,4644
 swarm/wsgi.py,sha256=REM_u4HpMCkO0ddrOUXgtY-ITL-VTbRB1-WHvFJAtAU,408
 swarm/agent/__init__.py,sha256=YESGu_UXEBxrlQwghodUMN0vmXZDwWMU7DclCUvoklA,104
 swarm/blueprints/README.md,sha256=tsngbSB9N0tILcz_m1OGAjyKZQYlGTN-i5e5asq1GbE,8478
-swarm/blueprints/burnt_noodles/blueprint_burnt_noodles.py,sha256=vopDlBjVUNeSq6WItdkmtWJfObgbtL6wNAy2njsskkY,19607
 swarm/blueprints/chatbot/blueprint_chatbot.py,sha256=a5-gIyDvRtNgbyfviD9Hua9r5NjOQh1lOafIG2a6kiI,7520
 swarm/blueprints/chatbot/templates/chatbot/chatbot.html,sha256=REFnqNg0EHsXxAUfaCJe1YgOKiV_umBXuC6y8veF5CU,1568
 swarm/blueprints/digitalbutlers/blueprint_digitalbutlers.py,sha256=JK_rmZgPMw4PdQFrMverrwgcjH0NRkuqkchYOJwXYuM,9809
-swarm/blueprints/dilbot_universe/blueprint_dilbot_universe.py,sha256=w7i96KkRNmBOV2Kz9SJqQCirsRPEgENR-79iLOzpKaQ,16770
 swarm/blueprints/divine_code/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 swarm/blueprints/divine_code/apps.py,sha256=k615JHdfOuo_GwfVbC7ah8X9OblkAL2XWm9aLBjmMyY,306
 swarm/blueprints/divine_code/blueprint_divine_code.py,sha256=YO-YE5ORvx4R_1VD2i60cPc21ZX6c8sXwOGTqmDk2Xw,13516
@@ -37,7 +35,6 @@ swarm/blueprints/family_ties/urls.py,sha256=awRZHb1gb1p3I6YZzfKMGSydd6kYPTLgax2j
 swarm/blueprints/family_ties/views.py,sha256=FbPkDNlFEixtRFbSpkr51IyJ28FRkXa1W5xyO_KeXH0,1081
 swarm/blueprints/flock/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 swarm/blueprints/gaggle/blueprint_gaggle.py,sha256=27KqO5M3x6vBQWN3AOWK6VJjuypygk05B1QeFWwZVEQ,10161
-swarm/blueprints/gotchaman/blueprint_gotchaman.py,sha256=bElwOpesPINuLJB_H8-1UoYiPvhnF_lFFjxUFHz0T5M,12326
 swarm/blueprints/mcp_demo/blueprint_mcp_demo.py,sha256=eUu5_BvLwVSdWiEonXWKuN7YgKsqz04JB_KbMPowryc,6599
 swarm/blueprints/messenger/templates/messenger/messenger.html,sha256=izuFtFn40Gm7M4gSUAUT5CIezjBjmNv2w4_fwSlv7VA,2323
 swarm/blueprints/mission_improbable/blueprint_mission_improbable.py,sha256=N4Tw0laErP4eCJM103XOaVrqbFNKZRUG1Bpze8g79MI,12753
@@ -255,8 +252,8 @@ swarm/views/message_views.py,sha256=sDUnXyqKXC8WwIIMAlWf00s2_a2T9c75Na5FvYMJwBM,
 swarm/views/model_views.py,sha256=aAbU4AZmrOTaPeKMWtoKK7FPYHdaN3Zbx55JfKzYTRY,2937
 swarm/views/utils.py,sha256=geX3Z5ZDKFYyXYBMilc-4qgOSjhujK3AfRtvbXgFpXk,3643
 swarm/views/web_views.py,sha256=ExQQeJpZ8CkLZQC_pXKOOmdnEy2qR3wEBP4LLp27DPU,7404
-open_swarm-0.1.1744936125.dist-info/METADATA,sha256=ddaFDVixx5XyE42kg6sn5ZIcFcy7rbfO-z-bl5QpIbI,13678
-open_swarm-0.1.1744936125.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-open_swarm-0.1.1744936125.dist-info/entry_points.txt,sha256=z1UIVRRhri-V-hWxFkDEYu0SZPUIsVO4KpDaodgcFzU,125
-open_swarm-0.1.1744936125.dist-info/licenses/LICENSE,sha256=BU9bwRlnOt_JDIb6OT55Q4leLZx9RArDLTFnlDIrBEI,1062
-open_swarm-0.1.1744936125.dist-info/RECORD,,
+open_swarm-0.1.1744936173.dist-info/METADATA,sha256=JSBqdb42N-rb3DZi99pEqnf6XqutDPsryC3TilVsJbA,13678
+open_swarm-0.1.1744936173.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+open_swarm-0.1.1744936173.dist-info/entry_points.txt,sha256=z1UIVRRhri-V-hWxFkDEYu0SZPUIsVO4KpDaodgcFzU,125
+open_swarm-0.1.1744936173.dist-info/licenses/LICENSE,sha256=BU9bwRlnOt_JDIb6OT55Q4leLZx9RArDLTFnlDIrBEI,1062
+open_swarm-0.1.1744936173.dist-info/RECORD,,

swarm/blueprints/burnt_noodles/blueprint_burnt_noodles.py

@@ -1,304 +0,0 @@
-import logging
-import os
-import sys
-import asyncio
-import subprocess
-import shlex # Added for safe command splitting
-import re
-import inspect
-from pathlib import Path # Use pathlib for better path handling
-from typing import Dict, Any, List, Optional, ClassVar, AsyncGenerator
-
-try:
-    # Core imports from openai-agents
-    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
-
-    # Import our custom base class
-    from swarm.extensions.blueprint.blueprint_base import BlueprintBase
-except ImportError as e:
-    # Provide more helpful error message
-    print(f"ERROR: Import failed in BurntNoodlesBlueprint: {e}. Check 'openai-agents' install and project structure.")
-    print(f"Attempted import from directory: {os.path.dirname(__file__)}")
-    print(f"sys.path: {sys.path}")
-    sys.exit(1)
-
-# Configure logging for this blueprint module
-logger = logging.getLogger(__name__)
-# Logging level is controlled by BlueprintBase based on --debug flag
-
-# --- Tool Logic Definitions (Undecorated) ---
-def _git_status_logic() -> str:
-    """Executes 'git status --porcelain' and returns the current repository status."""
-    logger.info("Executing git status --porcelain")
-    try:
-        result = subprocess.run(["git", "status", "--porcelain"], capture_output=True, text=True, check=True, timeout=30)
-        output = result.stdout.strip()
-        logger.debug(f"Git status raw output:\n{output}")
-        return f"OK: Git Status:\n{output}" if output else "OK: No changes detected in the working directory."
-    except FileNotFoundError: logger.error("Git command not found."); return "Error: git command not found."
-    except subprocess.CalledProcessError as e: logger.error(f"Error executing git status: {e.stderr}"); return f"Error executing git status: {e.stderr}"
-    except subprocess.TimeoutExpired: logger.error("Git status command timed out."); return "Error: Git status command timed out."
-    except Exception as e: logger.error(f"Unexpected error during git status: {e}", exc_info=logger.level <= logging.DEBUG); return f"Error during git status: {e}"
-
-def _git_diff_logic() -> str:
-    """Executes 'git diff' and returns the differences in the working directory."""
-    logger.info("Executing git diff")
-    try:
-        result = subprocess.run(["git", "diff"], capture_output=True, text=True, check=False, timeout=30)
-        output = result.stdout; stderr = result.stderr.strip()
-        if result.returncode != 0 and stderr: logger.error(f"Error executing git diff (Exit Code {result.returncode}): {stderr}"); return f"Error executing git diff: {stderr}"
-        logger.debug(f"Git diff raw output (Exit Code {result.returncode}):\n{output[:1000]}...")
-        return f"OK: Git Diff Output:\n{output}" if output else "OK: No differences found."
-    except FileNotFoundError: logger.error("Git command not found."); return "Error: git command not found."
-    except subprocess.TimeoutExpired: logger.error("Git diff command timed out."); return "Error: Git diff command timed out."
-    except Exception as e: logger.error(f"Unexpected error during git diff: {e}", exc_info=logger.level <= logging.DEBUG); return f"Error during git diff: {e}"
-
-def _git_add_logic(file_path: str = ".") -> str:
-    """Executes 'git add' to stage changes for the specified file or all changes (default '.')."""
-    logger.info(f"Executing git add {file_path}")
-    try:
-        result = subprocess.run(["git", "add", file_path], capture_output=True, text=True, check=True, timeout=30)
-        logger.debug(f"Git add '{file_path}' completed successfully.")
-        return f"OK: Staged '{file_path}' successfully."
-    except FileNotFoundError: logger.error("Git command not found."); return "Error: git command not found."
-    except subprocess.CalledProcessError as e: logger.error(f"Error executing git add '{file_path}': {e.stderr}"); return f"Error executing git add '{file_path}': {e.stderr}"
-    except subprocess.TimeoutExpired: logger.error(f"Git add command timed out for '{file_path}'."); return f"Error: Git add command timed out for '{file_path}'."
-    except Exception as e: logger.error(f"Unexpected error during git add '{file_path}': {e}", exc_info=logger.level <= logging.DEBUG); return f"Error during git add '{file_path}': {e}"
-
-def _git_commit_logic(message: str) -> str:
-    """Executes 'git commit' with a provided commit message."""
-    logger.info(f"Executing git commit -m '{message[:50]}...'")
-    if not message or not message.strip(): logger.warning("Git commit attempted with empty message."); return "Error: Commit message cannot be empty."
-    try:
-        result = subprocess.run(["git", "commit", "-m", message], capture_output=True, text=True, check=False, timeout=30)
-        output = result.stdout.strip(); stderr = result.stderr.strip()
-        logger.debug(f"Git commit raw output (Exit Code {result.returncode}):\nSTDOUT: {output}\nSTDERR: {stderr}")
-        if "nothing to commit" in output or "nothing added to commit" in output or "no changes added to commit" in output:
-             logger.info("Git commit reported: Nothing to commit."); return "OK: Nothing to commit."
-        if result.returncode == 0: return f"OK: Committed with message '{message}'.\n{output}"
-        else: error_detail = stderr if stderr else output; logger.error(f"Error executing git commit (Exit Code {result.returncode}): {error_detail}"); return f"Error executing git commit: {error_detail}"
-    except FileNotFoundError: logger.error("Git command not found."); return "Error: git command not found."
-    except subprocess.TimeoutExpired: logger.error("Git commit command timed out."); return "Error: Git commit command timed out."
-    except Exception as e: logger.error(f"Unexpected error during git commit: {e}", exc_info=logger.level <= logging.DEBUG); return f"Error during git commit: {e}"
-
-def _git_push_logic() -> str:
-    """Executes 'git push' to push staged commits to the remote repository."""
-    logger.info("Executing git push")
-    try:
-        result = subprocess.run(["git", "push"], capture_output=True, text=True, check=True, timeout=120)
-        output = result.stdout.strip() + "\n" + result.stderr.strip()
-        logger.debug(f"Git push raw output:\n{output}")
-        return f"OK: Push completed.\n{output.strip()}"
-    except FileNotFoundError: logger.error("Git command not found."); return "Error: git command not found."
-    except subprocess.CalledProcessError as e: error_output = e.stdout.strip() + "\n" + e.stderr.strip(); logger.error(f"Error executing git push: {error_output}"); return f"Error executing git push: {error_output.strip()}"
-    except subprocess.TimeoutExpired: logger.error("Git push command timed out."); return "Error: Git push command timed out."
-    except Exception as e: logger.error(f"Unexpected error during git push: {e}", exc_info=logger.level <= logging.DEBUG); return f"Error during git push: {e}"
-
-def _run_npm_test_logic(args: str = "") -> str:
-    """Executes 'npm run test' with optional arguments."""
-    try:
-        cmd_list = ["npm", "run", "test"] + (shlex.split(args) if args else []); cmd_str = ' '.join(cmd_list)
-        logger.info(f"Executing npm test: {cmd_str}")
-        result = subprocess.run(cmd_list, capture_output=True, text=True, check=False, timeout=120)
-        output = f"Exit Code: {result.returncode}\nSTDOUT:\n{result.stdout.strip()}\nSTDERR:\n{result.stderr.strip()}"
-        if result.returncode == 0: logger.debug(f"npm test completed successfully:\n{output}"); return f"OK: npm test finished.\n{output}"
-        else: logger.error(f"npm test failed (Exit Code {result.returncode}):\n{output}"); return f"Error: npm test failed.\n{output}"
-    except FileNotFoundError: logger.error("npm command not found."); return "Error: npm command not found."
-    except subprocess.TimeoutExpired: logger.error("npm test command timed out."); return "Error: npm test command timed out."
-    except Exception as e: logger.error(f"Unexpected error during npm test: {e}", exc_info=logger.level <= logging.DEBUG); return f"Error during npm test: {e}"
-
-def _run_pytest_logic(args: str = "") -> str:
-    """Executes 'uv run pytest' with optional arguments."""
-    try:
-        cmd_list = ["uv", "run", "pytest"] + (shlex.split(args) if args else []); cmd_str = ' '.join(cmd_list)
-        logger.info(f"Executing pytest via uv: {cmd_str}")
-        result = subprocess.run(cmd_list, capture_output=True, text=True, check=False, timeout=120)
-        output = f"Exit Code: {result.returncode}\nSTDOUT:\n{result.stdout.strip()}\nSTDERR:\n{result.stderr.strip()}"
-        if result.returncode == 0: logger.debug(f"pytest completed successfully:\n{output}"); return f"OK: pytest finished successfully.\n{output}"
-        else: logger.warning(f"pytest finished with failures (Exit Code {result.returncode}):\n{output}"); return f"OK: Pytest finished with failures (Exit Code {result.returncode}).\n{output}"
-    except FileNotFoundError: logger.error("uv command not found."); return "Error: uv command not found."
-    except subprocess.TimeoutExpired: logger.error("pytest command timed out."); return "Error: pytest command timed out."
-    except Exception as e: logger.error(f"Unexpected error during pytest: {e}", exc_info=logger.level <= logging.DEBUG); return f"Error during pytest: {e}"
-
-# --- Tool Definitions (Decorated - reverted to default naming) ---
-git_status = function_tool(_git_status_logic)
-git_diff = function_tool(_git_diff_logic)
-git_add = function_tool(_git_add_logic)
-git_commit = function_tool(_git_commit_logic)
-git_push = function_tool(_git_push_logic)
-run_npm_test = function_tool(_run_npm_test_logic)
-run_pytest = function_tool(_run_pytest_logic)
-
-# --- Agent Instructions ---
-# (Instructions remain the same)
-michael_instructions = """
-You are Michael Toasted, the resolute leader of the Burnt Noodles creative team.
-Your primary role is to understand the user's request, break it down into actionable steps,
-and delegate tasks appropriately to your team members: Fiona Flame (Git operations) and Sam Ashes (Testing).
-You should only execute simple Git status checks (`git_status`, `git_diff`) yourself. Delegate all other Git actions (add, commit, push) to Fiona. Delegate all testing actions (npm test, pytest) to Sam.
-Synthesize the results from your team and provide the final response to the user.
-Available Function Tools (for you): git_status, git_diff.
-Available Agent Tools (for delegation): Fiona_Flame, Sam_Ashes.
-"""
-fiona_instructions = """
-You are Fiona Flame, the git specialist. Execute git commands precisely as requested using your available function tools:
-`git_status`, `git_diff`, `git_add`, `git_commit`, `git_push`.
-When asked to commit, analyze the diff if necessary and generate concise, informative conventional commit messages (e.g., 'feat: ...', 'fix: ...', 'refactor: ...', 'chore: ...').
-Always stage changes using `git_add` before committing.
-If asked to push, first ask the user (Michael) for confirmation before executing `git_push`.
-If a task involves testing (like running tests after a commit), delegate it to the Sam_Ashes agent tool.
-For tasks outside your Git domain, report back to Michael; do not use the Michael_Toasted tool directly.
-Available Function Tools: git_status, git_diff, git_add, git_commit, git_push.
-Available Agent Tools: Sam_Ashes.
-"""
-sam_instructions = """
-You are Sam Ashes, the meticulous testing operative. Execute test commands using your available function tools: `run_npm_test` or `run_pytest`.
-Interpret the results: Report failures immediately and clearly. If tests pass, consider running with coverage (e.g., using `uv run pytest --cov` via the `run_pytest` tool) if appropriate or requested, and report the coverage summary.
-For tasks outside testing (e.g., needing code changes before testing, or git operations), refer back to Michael; do not use the Michael_Toasted or Fiona_Flame tools directly.
-Available Function Tools: run_npm_test, run_pytest.
-Available Agent Tools: None (Report back to Michael for delegation).
-"""
-
-# --- Blueprint Definition ---
-class BurntNoodlesBlueprint(BlueprintBase):
-    metadata: ClassVar[Dict[str, Any]] = {
-        "name": "BurntNoodlesBlueprint",
-        "title": "Burnt Noodles",
-        "description": "A multi-agent team managing Git operations and code testing.",
-        "version": "1.1.0",
-        "author": "Open Swarm Team (Refactored)",
-        "tags": ["git", "test", "multi-agent", "collaboration", "refactor"],
-        "required_mcp_servers": [],
-    }
-
-    _openai_client_cache: Dict[str, AsyncOpenAI] = {}
-    _model_instance_cache: Dict[str, Model] = {}
-
-    def _get_model_instance(self, profile_name: str) -> Model:
-        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 = getattr(self, "get_llm_profile", lambda prof: {"provider": "openai", "model": "gpt-mock"})(profile_name)
-        if not profile_data:
-             logger.critical(f"Cannot create Model instance: LLM profile '{profile_name}' (or 'default') not found in configuration.")
-             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}' is missing the required 'model' key.")
-             raise ValueError(f"Missing 'model' key in LLM profile '{profile_name}'.")
-
-        if provider != "openai":
-            logger.error(f"Unsupported LLM provider '{provider}' in profile '{profile_name}'. Only 'openai' is supported in this blueprint.")
-            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_client_kwargs = {k: v for k, v in client_kwargs.items() if v is not None}
-             log_client_kwargs = {k:v for k,v in filtered_client_kwargs.items() if k != 'api_key'}
-             logger.debug(f"Creating new AsyncOpenAI client for profile '{profile_name}' with config: {log_client_kwargs}")
-             try:
-                 self._openai_client_cache[client_cache_key] = AsyncOpenAI(**filtered_client_kwargs)
-             except Exception as e:
-                 logger.error(f"Failed to create AsyncOpenAI client for profile '{profile_name}': {e}", exc_info=True)
-                 raise ValueError(f"Failed to initialize OpenAI client for profile '{profile_name}': {e}") from e
-
-        openai_client_instance = self._openai_client_cache[client_cache_key]
-
-        logger.debug(f"Instantiating OpenAIChatCompletionsModel(model='{model_name}') with client instance for profile '{profile_name}'.")
-        try:
-            model_instance = OpenAIChatCompletionsModel(model=model_name, openai_client=openai_client_instance)
-            self._model_instance_cache[profile_name] = model_instance
-            return model_instance
-        except Exception as e:
-             logger.error(f"Failed to instantiate OpenAIChatCompletionsModel for profile '{profile_name}': {e}", exc_info=True)
-             raise ValueError(f"Failed to initialize LLM provider for profile '{profile_name}': {e}") from e
-
-    def create_starting_agent(self, mcp_servers: List[MCPServer]) -> Agent:
-        logger.debug("Creating Burnt Noodles agent team...")
-        config = self._load_configuration() if getattr(self, "config", None) is None else self.config
-        self._model_instance_cache = {}
-        self._openai_client_cache = {}
-
-        default_profile_name = config.get("llm_profile", "default")
-        logger.debug(f"Using LLM profile '{default_profile_name}' for all Burnt Noodles agents.")
-        default_model_instance = self._get_model_instance(default_profile_name)
-
-        # --- Use the decorated tool variables ---
-        fiona_flame = Agent(
-            name="Fiona_Flame",
-            model=default_model_instance,
-            instructions=fiona_instructions,
-            tools=[git_status, git_diff, git_add, git_commit, git_push] # Agent tools added later
-        )
-        sam_ashes = Agent(
-            name="Sam_Ashes",
-            model=default_model_instance,
-            instructions=sam_instructions,
-            tools=[run_npm_test, run_pytest] # Agent tools added later
-        )
-        michael_toasted = Agent(
-             name="Michael_Toasted",
-             model=default_model_instance,
-             instructions=michael_instructions,
-             tools=[
-                 git_status, # Michael's direct tools
-                 git_diff,
-                 fiona_flame.as_tool(
-                     tool_name="Fiona_Flame",
-                     tool_description="Delegate Git operations (add, commit, push) or complex status/diff queries to Fiona."
-                 ),
-                 sam_ashes.as_tool(
-                     tool_name="Sam_Ashes",
-                     tool_description="Delegate testing tasks (npm test, pytest) to Sam."
-                 ),
-             ],
-             mcp_servers=mcp_servers
-        )
-        # --- End tool variable usage ---
-
-        fiona_flame.tools.append(
-            sam_ashes.as_tool(tool_name="Sam_Ashes", tool_description="Delegate testing tasks (npm test, pytest) to Sam.")
-        )
-
-        logger.debug("Burnt Noodles agent team created successfully. Michael Toasted is the starting agent.")
-        return michael_toasted
-
-    async def run(self, messages: List[Dict[str, Any]], **kwargs) -> AsyncGenerator[Dict[str, Any], None]:
-        """
-        Main execution entry point for the Burnt Noodles blueprint.
-        Delegates to _run_non_interactive for CLI-like execution.
-        """
-        logger.info("BurntNoodlesBlueprint 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("BurntNoodlesBlueprint run method finished.")
-
-    async def _run_non_interactive(self, instruction: str, **kwargs) -> AsyncGenerator[Dict[str, Any], None]:
-        """Helper to run the agent flow based on an instruction."""
-        logger.info(f"Running Burnt Noodles non-interactively with instruction: '{instruction[:100]}...'")
-        mcp_servers = kwargs.get("mcp_servers", [])
-        starting_agent = self.create_starting_agent(mcp_servers=mcp_servers)
-        runner = Runner(agent=starting_agent)
-        try:
-            final_result = await runner.run(instruction)
-            logger.info(f"Non-interactive run finished. Final Output: {final_result.final_output}")
-            yield { "messages": [ {"role": "assistant", "content": final_result.final_output} ] }
-        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}"} ] }
-
-
-# Standard Python entry point for direct script execution
-if __name__ == "__main__":
-    BurntNoodlesBlueprint.main()
-

swarm/blueprints/dilbot_universe/blueprint_dilbot_universe.py

@@ -1,285 +0,0 @@
-import logging
-import random
-import json
-import os
-import sys
-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 DilbotUniverseBlueprint: {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"
-
-# --- Placeholder Tools ---
-@function_tool
-def build_product() -> str:
-    """Simulates successfully building the product."""
-    logger.info("Tool: build_product executed.")
-    return (
-        "ACTION: build_product completed.\n"
-        "GAME OVER: YOU WON!\n"
-        "After much deliberation, the comedic masterpiece is finalized—behold its glory! "
-        "Reasoning: It’s polished enough to survive the corporate circus."
-    )
-
-@function_tool
-def sabotage_project() -> str:
-    """Simulates sabotaging the project."""
-    logger.info("Tool: sabotage_project executed.")
-    return (
-        "ACTION: sabotage_project completed.\n"
-        "GAME OVER: YOU LOST!\n"
-        "The project has been gleefully trashed—chaos reigns supreme! "
-        "Reasoning: Why build when you can break with style?"
-    )
-
-# --- Blueprint Definition ---
-class DilbotUniverseBlueprint(BlueprintBase):
-    """A comedic multi-agent blueprint simulating a 9-step SDLC, using agent-as-tool for handoffs and SQLite for instructions."""
-    metadata: ClassVar[Dict[str, Any]] = {
-            "name": "DilbotUniverseBlueprint",
-            "title": "Dilbot Universe SDLC (SQLite)",
-            "description": "A comedic multi-agent blueprint using agent-as-tool handoffs and SQLite for instructions.",
-            "version": "1.2.0", # Version bump for SQLite change
-            "author": "Open Swarm Team (Refactored)",
-            "tags": ["comedy", "multi-agent", "sdlc", "sqlite", "dynamic-config"],
-            "required_mcp_servers": [],
-            "cli_name": "dilbot",
-            "env_vars": [],
-        }
-
-    # Caches
-    _openai_client_cache: Dict[str, AsyncOpenAI] = {}
-    _model_instance_cache: Dict[str, Model] = {}
-    _db_initialized = False # Flag to ensure DB init runs only once per instance
-
-    # --- Database Interaction ---
-    def _init_db_and_load_data(self) -> None:
-        """Initializes the SQLite DB, creates table, and loads sample data if needed."""
-        if self._db_initialized:
-            return
-
-        logger.info(f"Initializing SQLite database at: {DB_PATH}")
-        try:
-            # Ensure directory exists (though DB_PATH is project root here)
-            DB_PATH.parent.mkdir(parents=True, exist_ok=True)
-
-            with sqlite3.connect(DB_PATH) as conn:
-                cursor = conn.cursor()
-                # Create table if it doesn't exist
-                cursor.execute(f"""
-                CREATE TABLE IF NOT EXISTS {TABLE_NAME} (
-                    agent_name TEXT PRIMARY KEY,
-                    instruction_text TEXT NOT NULL,
-                    model_profile TEXT DEFAULT 'default'
-                )
-                """)
-                logger.debug(f"Table '{TABLE_NAME}' ensured in {DB_PATH}")
-
-                # Check if data needs loading (check for a known agent)
-                cursor.execute(f"SELECT COUNT(*) FROM {TABLE_NAME} WHERE agent_name = ?", ("Dilbot",))
-                count = cursor.fetchone()[0]
-
-                if count == 0:
-                    logger.info(f"No instructions found for Dilbot in {DB_PATH}. Loading sample data...")
-                    sample_instructions = [
-                        ("Dilbot", "You are Dilbot, a meticulous engineer... [Full instructions]", "default"),
-                        ("Alisa", "You are Alisa, a creative designer... [Full instructions]", "default"),
-                        ("Carola", "You are Carola, an organized manager... [Full instructions]", "default"),
-                        ("PointyBoss", "You are PointyBoss, an evil manager... [Full instructions]", "default"),
-                        ("Dogbot", "You are Dogbot, an evil consultant... [Full instructions]", "default"),
-                        ("Waldo", "You are Waldo, a lazy neutral employee... [Full instructions]", "default"),
-                        ("Asoka", "You are Asoka, an eager neutral intern... [Full instructions]", "default"),
-                        ("Ratbot", "You are Ratbot, a whimsical neutral character... [Full instructions]", "default"),
-                    ]
-                    # Replace "[Full instructions]" with the actual long instructions from the previous version
-                    # Example for Dilbot:
-                    sample_instructions[0] = (
-                        "Dilbot",
-                        "You are Dilbot, a meticulous engineer. Follow a 9-step SDLC: 1) Ask engineering questions, 2) Probe further, 3) 1/3 chance to build or pass to Waldo (reason first), 4-5) More questions, 6) 2/3 chance to build or pass, 7-8) Final questions, 9) Build or pass with comedic reasoning.",
-                        "default"
-                    )
-                    # ... (Add the other full instructions here) ...
-                    # For brevity, using placeholders:
-                    sample_instructions[1] = ("Alisa", sample_instructions[1][1].replace("... [Full instructions]", "... Follow a 9-step SDLC: 1) Ask design questions... 9) Build or pass with comedic reasoning."), "default")
-                    sample_instructions[2] = ("Carola", sample_instructions[2][1].replace("... [Full instructions]", "... Follow a 9-step SDLC: 1) Ask scheduling questions... 9) Build or pass with comedic reasoning."), "default")
-                    sample_instructions[3] = ("PointyBoss", sample_instructions[3][1].replace("... [Full instructions]", "... Follow a 9-step SDLC: 1) Ask business questions... 9) Sabotage or pass with comedic reasoning."), "default")
-                    sample_instructions[4] = ("Dogbot", sample_instructions[4][1].replace("... [Full instructions]", "... Follow a 9-step SDLC: 1) Ask consultancy questions... 9) Sabotage or pass with comedic reasoning."), "default")
-                    sample_instructions[5] = ("Waldo", sample_instructions[5][1].replace("... [Full instructions]", "... Follow a 9-step SDLC: 1) Ask procrastination questions... 9) Pass to Dilbot or Dogbot with comedic reasoning."), "default")
-                    sample_instructions[6] = ("Asoka", sample_instructions[6][1].replace("... [Full instructions]", "... Follow a 9-step SDLC: 1) Ask creative questions... 9) Pass to Carola or PointyBoss with comedic reasoning."), "default")
-                    sample_instructions[7] = ("Ratbot", sample_instructions[7][1].replace("... [Full instructions]", "... Follow a 9-step SDLC: 1) Ask nonsense questions... 9) Pass to Dilbot or Dogbot with comedic reasoning."), "default")
-
-
-                    cursor.executemany(f"INSERT INTO {TABLE_NAME} (agent_name, instruction_text, model_profile) VALUES (?, ?, ?)", sample_instructions)
-                    conn.commit()
-                    logger.info(f"Sample agent instructions loaded into {DB_PATH}")
-                else:
-                    logger.info(f"Agent instructions found in {DB_PATH}. Skipping sample data loading.")
-
-            self._db_initialized = True
-
-        except sqlite3.Error as e:
-            logger.error(f"SQLite error during DB initialization/loading: {e}", exc_info=True)
-            # Continue without DB? Or raise error? Let's warn and continue with defaults.
-            self._db_initialized = False # Mark as failed
-        except Exception as e:
-            logger.error(f"Unexpected error during DB initialization/loading: {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 # Access columns by name
-                    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",
-                        }
-                    else:
-                        logger.warning(f"No config found for agent '{agent_name}' in SQLite. Using defaults.")
-            except sqlite3.Error as e:
-                logger.error(f"SQLite error fetching config for '{agent_name}': {e}. Using defaults.", exc_info=True)
-            except Exception as e:
-                 logger.error(f"Unexpected error fetching config for '{agent_name}': {e}. Using defaults.", exc_info=True)
-
-        # --- Fallback Hardcoded Defaults ---
-        logger.warning(f"Using hardcoded default config for agent '{agent_name}'.")
-        default_instructions = {
-            "Dilbot": "You are Dilbot, a meticulous engineer... [Default Instructions - DB Failed]",
-            # ... (Add other default instructions here) ...
-             "Alisa": "You are Alisa... [Default Instructions - DB Failed]",
-             "Carola": "You are Carola... [Default Instructions - DB Failed]",
-             "PointyBoss": "You are PointyBoss... [Default Instructions - DB Failed]",
-             "Dogbot": "You are Dogbot... [Default Instructions - DB Failed]",
-             "Waldo": "You are Waldo... [Default Instructions - DB Failed]",
-             "Asoka": "You are Asoka... [Default Instructions - DB Failed]",
-             "Ratbot": "You are Ratbot... [Default Instructions - DB Failed]",
-        }
-        return {
-            "instructions": default_instructions.get(agent_name, f"Default instructions for {agent_name}."),
-            "model_profile": "default",
-        }
-
-    # --- Model Instantiation Helper --- (Copied from previous step)
-    def _get_model_instance(self, profile_name: str) -> Model:
-        """Retrieves or creates an LLM Model instance."""
-        # ... (Implementation remains the same as in the previous response) ...
-        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}' in profile '{profile_name}'.")
-            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_client_kwargs = {k: v for k, v in client_kwargs.items() if v is not None}
-             log_client_kwargs = {k:v for k,v in filtered_client_kwargs.items() if k != 'api_key'}
-             logger.debug(f"Creating new AsyncOpenAI client for profile '{profile_name}' with config: {log_client_kwargs}")
-             try: self._openai_client_cache[client_cache_key] = AsyncOpenAI(**filtered_client_kwargs)
-             except Exception as e: raise ValueError(f"Failed to initialize OpenAI client: {e}") from e
-        openai_client_instance = 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=openai_client_instance)
-            self._model_instance_cache[profile_name] = model_instance
-            return model_instance
-        except Exception as e: raise ValueError(f"Failed to initialize LLM provider: {e}") from e
-
-
-    # --- Agent Creation ---
-    def create_starting_agent(self, mcp_servers: List[MCPServer]) -> Agent:
-        """Creates the Dilbot Universe agent team using SQLite for instructions."""
-        # Initialize DB and load data if needed (runs only once)
-        self._init_db_and_load_data()
-
-        logger.debug("Creating Dilbot Universe agent team...")
-        self._model_instance_cache = {} # Clear model cache for this run
-        self._openai_client_cache = {} # Clear client cache for this run
-
-        agents: Dict[str, Agent] = {}
-        agent_names = ["Dilbot", "Alisa", "Carola", "PointyBoss", "Dogbot", "Waldo", "Asoka", "Ratbot"]
-
-        # Create all agents first so they can be used as tools
-        for name in agent_names:
-            config = self.get_agent_config(name)
-            model_instance = self._get_model_instance(config["model_profile"])
-            agents[name] = Agent(
-                name=name,
-                instructions=config["instructions"],
-                model=model_instance,
-                tools=[], # Tools (including agent-as-tool) added below
-                mcp_servers=mcp_servers # Pass full list for simplicity now
-            )
-
-        # --- Define Tools & Agent-as-Tool Delegations ---
-        action_tools = [build_product, sabotage_project]
-
-        # Add tools based on agent logic (using Agent-as-Tool for passes)
-        agents["Dilbot"].tools.extend([action_tools[0], agents["Waldo"].as_tool(tool_name="Waldo", tool_description="Pass task to Waldo.")])
-        agents["Alisa"].tools.extend([action_tools[0], agents["Asoka"].as_tool(tool_name="Asoka", tool_description="Pass task to Asoka.")])
-        agents["Carola"].tools.extend([action_tools[0], agents["Waldo"].as_tool(tool_name="Waldo", tool_description="Pass task to Waldo.")])
-        agents["PointyBoss"].tools.extend([action_tools[1], agents["Waldo"].as_tool(tool_name="Waldo", tool_description="Pass task to Waldo.")])
-        agents["Dogbot"].tools.extend([action_tools[1], agents["Ratbot"].as_tool(tool_name="Ratbot", tool_description="Pass task to Ratbot.")])
-        agents["Waldo"].tools.extend([
-            agents["Dilbot"].as_tool(tool_name="Dilbot", tool_description="Pass task to Dilbot."),
-            agents["Dogbot"].as_tool(tool_name="Dogbot", tool_description="Pass task to Dogbot.")
-        ])
-        agents["Asoka"].tools.extend([
-            agents["Carola"].as_tool(tool_name="Carola", tool_description="Pass task to Carola."),
-            agents["PointyBoss"].as_tool(tool_name="PointyBoss", tool_description="Pass task to PointyBoss.")
-        ])
-        agents["Ratbot"].tools.extend([
-            agents["Dilbot"].as_tool(tool_name="Dilbot", tool_description="Pass task to Dilbot."),
-            agents["Dogbot"].as_tool(tool_name="Dogbot", tool_description="Pass task to Dogbot.")
-        ])
-
-        # Randomly select starting agent from neutrals
-        neutral_agents = ["Waldo", "Asoka", "Ratbot"]
-        start_name = random.choice(neutral_agents)
-        starting_agent = agents[start_name]
-
-        logger.info(f"Dilbot Universe agents created (using SQLite). Starting agent: {start_name}")
-        return starting_agent
-
-# Standard Python entry point
-if __name__ == "__main__":
-    # No Django setup needed here anymore
-    DilbotUniverseBlueprint.main()

swarm/blueprints/gotchaman/blueprint_gotchaman.py

@@ -1,232 +0,0 @@
-"""
-Gotchaman: CLI Automation Blueprint
-
-This blueprint provides CLI automation capabilities using a team of agents:
-- Ken (Coordinator)
-- Joe (Runner - executes commands/file ops)
-- Jun (Logger - hypothetical monitoring via MCP)
-- Jinpei (Advisor - hypothetical suggestion via MCP)
-- Ryu (Reviewer - hypothetical insights via MCP)
-
-Uses BlueprintBase, @function_tool for local commands, and agent-as-tool delegation.
-"""
-
-import os
-import sys
-import logging
-import subprocess
-import shlex # For safe command splitting
-from pathlib import Path # Use pathlib
-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 GotchamanBlueprint: {e}. Check dependencies.")
-    print(f"sys.path: {sys.path}")
-    sys.exit(1)
-
-logger = logging.getLogger(__name__)
-
-# --- Function Tools ---
-@function_tool
-def execute_command(command: str) -> str:
-    """Executes a shell command and returns its stdout and stderr."""
-    if not command: return "Error: No command provided."
-    logger.info(f"Tool: Executing command: {command}")
-    try:
-        # Use shell=True cautiously, consider splitting if possible for safer execution
-        result = subprocess.run(
-            command,
-            shell=True, # Be cautious with shell=True
-            check=False, # Capture output even on error
-            capture_output=True,
-            text=True,
-            timeout=120
-        )
-        output = f"Exit Code: {result.returncode}\nSTDOUT:\n{result.stdout.strip()}\nSTDERR:\n{result.stderr.strip()}"
-        if result.returncode == 0:
-            logger.debug(f"Command successful:\n{output}")
-            return f"OK: Command executed.\n{output}"
-        else:
-            logger.error(f"Command failed:\n{output}")
-            return f"Error: Command failed.\n{output}"
-    except FileNotFoundError:
-         # This error is less likely with shell=True unless the shell itself is missing
-         logger.error(f"Error executing command '{command}': Shell or command not found.")
-         return f"Error: Shell or command '{command.split()[0]}' not found."
-    except subprocess.TimeoutExpired:
-        logger.error(f"Command '{command}' timed out.")
-        return f"Error: Command '{command}' timed out."
-    except Exception as e:
-        logger.error(f"Unexpected error executing command '{command}': {e}", exc_info=logger.level <= logging.DEBUG)
-        return f"Error: Unexpected error during command execution: {e}"
-
-@function_tool
-def read_file(path: str) -> str:
-    """Reads the content of a file at the specified path."""
-    if not path: return "Error: No file path provided."
-    logger.info(f"Tool: Reading file at: {path}")
-    try:
-        file_path = Path(path).resolve()
-        # Optional: Add security check to ensure path is within allowed bounds if needed
-        # cwd = Path.cwd()
-        # if not str(file_path).startswith(str(cwd)):
-        #     logger.warning(f"Attempt to read file outside current working directory: {path}")
-        #     return f"Error: Access denied to path: {path}"
-        if not file_path.is_file():
-             logger.error(f"File not found at: {file_path}")
-             return f"Error: File not found at path: {path}"
-        content = file_path.read_text(encoding="utf-8")
-        logger.debug(f"Read {len(content)} characters from {file_path}.")
-        return f"OK: Content of {path}:\n{content}"
-    except Exception as e:
-        logger.error(f"Error reading file at {path}: {e}", exc_info=logger.level <= logging.DEBUG)
-        return f"Error reading file '{path}': {e}"
-
-@function_tool
-def write_file(path: str, content: str) -> str:
-    """Writes content to a file at the specified path, overwriting if it exists."""
-    if not path: return "Error: No file path provided."
-    logger.info(f"Tool: Writing {len(content)} characters to file at: {path}")
-    try:
-        file_path = Path(path).resolve()
-        # Optional: Add security check
-        # cwd = Path.cwd()
-        # if not str(file_path).startswith(str(cwd)):
-        #     logger.warning(f"Attempt to write file outside current working directory: {path}")
-        #     return f"Error: Access denied to path: {path}"
-
-        file_path.parent.mkdir(parents=True, exist_ok=True) # Ensure directory exists
-        file_path.write_text(content, encoding="utf-8")
-        logger.debug(f"Successfully wrote to {file_path}.")
-        return f"OK: Successfully wrote to {path}."
-    except Exception as e:
-        logger.error(f"Error writing file at {path}: {e}", exc_info=logger.level <= logging.DEBUG)
-        return f"Error writing file '{path}': {e}"
-
-# --- Define the Blueprint ---
-class GotchamanBlueprint(BlueprintBase):
-    """Gotchaman: CLI Automation Blueprint using BlueprintBase."""
-
-    metadata: ClassVar[Dict[str, Any]] = {
-        "name": "GotchamanBlueprint",
-        "title": "Gotchaman: CLI Automation",
-        "description": (
-            "A blueprint for automating CLI tasks using a team of agents (Ken, Joe, Jun, Jinpei, Ryu) "
-            "with specific roles and MCP/tool access."
-        ),
-        "version": "1.1.0", # Refactored version
-        "author": "Open Swarm Team (Refactored)",
-        "tags": ["cli", "automation", "multi-agent", "mcp", "slack", "monday"],
-        # List only servers directly used by refactored agents
-        "required_mcp_servers": ["slack", "mondayDotCom", "basic-memory", "mcp-npx-fetch"],
-        "env_vars": ["SLACK_API_KEY", "MONDAY_API_KEY"]
-    }
-
-     # 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 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 Gotchaman agent team and returns Ken (Coordinator)."""
-        logger.debug("Creating Gotchaman 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 Gotchaman agents.")
-        model_instance = self._get_model_instance(default_profile_name)
-
-        # 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]
-
-        # --- Agent Instructions ---
-        ken_instructions = "You are Ken, the Coordinator for Gotchaman team. Your team: Joe (Runner), Jun (Logger), Jinpei (Advisor), and Ryu (Reviewer). Analyze the user request and delegate tasks to the appropriate agent using their Agent Tool. Synthesize their responses for the final output."
-        joe_instructions = "You are Joe, the Runner. Execute shell commands, read files, or write files using your function tools (`execute_command`, `read_file`, `write_file`) as requested by Ken. Report the outcome."
-        jun_instructions = "You are Jun, the Logger. Receive information or instructions from Ken. Use the `slack` MCP tool to log messages or feedback to a designated channel (details provided by Ken or pre-configured). Report success/failure of logging back to Ken."
-        jinpei_instructions = "You are Jinpei, the Advisor. Receive context from Ken. Use the `mcp-npx-fetch` MCP tool to fetch relevant documentation or examples based on the context. Provide concise suggestions or relevant snippets back to Ken."
-        ryu_instructions = "You are Ryu, the Reviewer. Receive outputs or code snippets from Ken. Use the `basic-memory` MCP tool to recall previous related outputs or guidelines if necessary. Provide insightful review comments or quality checks back to Ken."
-
-        # Instantiate agents
-        joe_agent = Agent(
-            name="Joe", model=model_instance, instructions=joe_instructions,
-            tools=[execute_command, read_file, write_file], # Joe has the function tools
-            mcp_servers=[] # Joe doesn't directly use MCPs listed
-        )
-        jun_agent = Agent(
-            name="Jun", model=model_instance, instructions=jun_instructions,
-            tools=[], # Jun uses MCP
-            mcp_servers=get_agent_mcps(["slack"])
-        )
-        jinpei_agent = Agent(
-            name="Jinpei", model=model_instance, instructions=jinpei_instructions,
-            tools=[], # Jinpei uses MCP
-            mcp_servers=get_agent_mcps(["mcp-npx-fetch"])
-        )
-        ryu_agent = Agent(
-            name="Ryu", model=model_instance, instructions=ryu_instructions,
-            tools=[], # Ryu uses MCP
-            mcp_servers=get_agent_mcps(["basic-memory"])
-        )
-        # Coordinator - Ken
-        ken_agent = Agent(
-            name="Ken", model=model_instance, instructions=ken_instructions,
-            tools=[ # Ken delegates to others via agent tools
-                joe_agent.as_tool(tool_name="Joe", tool_description="Delegate command execution or file operations to Joe."),
-                jun_agent.as_tool(tool_name="Jun", tool_description="Delegate logging tasks via Slack to Jun."),
-                jinpei_agent.as_tool(tool_name="Jinpei", tool_description="Delegate fetching docs/examples to Jinpei."),
-                ryu_agent.as_tool(tool_name="Ryu", tool_description="Delegate review tasks or recall past info via Ryu."),
-            ],
-             # Ken might use memory directly, or coordinate access via Ryu? Assigning for potential direct use.
-            mcp_servers=get_agent_mcps(["basic-memory"])
-        )
-
-        logger.debug("Gotchaman agents created. Starting with Ken.")
-        return ken_agent
-
-# Standard Python entry point
-if __name__ == "__main__":
-    GotchamanBlueprint.main()