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

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

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

@@ -16,34 +16,34 @@ swarm/agent/__init__.py,sha256=YESGu_UXEBxrlQwghodUMN0vmXZDwWMU7DclCUvoklA,104
 swarm/blueprints/README.md,sha256=tsngbSB9N0tILcz_m1OGAjyKZQYlGTN-i5e5asq1GbE,8478
 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/digitalbutlers/blueprint_digitalbutlers.py,sha256=bQ0h_oC7TBbwjXhlSDGgjsnePb8cRcCnft2CggZuLY0,11301
 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
+swarm/blueprints/divine_code/blueprint_divine_code.py,sha256=p4A9RhvBrWy6OKFNWCxKUqQAmkc49xcSh5V0FGiZ50k,14994
 swarm/blueprints/django_chat/apps.py,sha256=rn1Eu11c4zZ6DYZeFb6AkCDMoM_dcQTzeNwW-IxXpCI,200
-swarm/blueprints/django_chat/blueprint_django_chat.py,sha256=jROcPgqNJZv2E2efCoGzouXHnHZP1JJundj0R3VTNbM,3376
+swarm/blueprints/django_chat/blueprint_django_chat.py,sha256=kaxR7mV6mYW3HQTLO36xpCP2jhbj_sb4VKnMgE9GiWo,3716
 swarm/blueprints/django_chat/urls.py,sha256=TTTF3pgymvCYbuxpwi4WRBPv8ftQNH4pEoURT8sEVAg,147
 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=6xQT9qb2mIf28TAj1N4lWN1PzTq4CWVmPeTG_3Flrpc,2740
+swarm/blueprints/echocraft/blueprint_echocraft.py,sha256=Bv9ceqPQgPtWDHtmZejJn9YyXPJOA4uUwXnQpBcG52g,3145
 swarm/blueprints/family_ties/apps.py,sha256=EjV7AxDNsLM4gsLr_qMEiLAVbERuo1ZsdU9vPtOEYAY,287
-swarm/blueprints/family_ties/blueprint_family_ties.py,sha256=XVcSZNHmqQNqyjDZM36wtUh2V2Qx2_lComjD7E7er1A,7986
+swarm/blueprints/family_ties/blueprint_family_ties.py,sha256=Pkqgf7oF5Ag8YddeeLbGPreb4r1YdGSYSsOQmZ18VIM,9462
 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/gaggle/blueprint_gaggle.py,sha256=27KqO5M3x6vBQWN3AOWK6VJjuypygk05B1QeFWwZVEQ,10161
+swarm/blueprints/gaggle/blueprint_gaggle.py,sha256=4H_eJQEzmw56IiadhMa8dYqHeiY9ubJiK5ziffo01Zs,14151
 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
-swarm/blueprints/monkai_magic/blueprint_monkai_magic.py,sha256=r0q6fV6QNsF28UHwO5RtZTwofke2YfHrlRAZtGgT9Yo,13315
-swarm/blueprints/nebula_shellz/blueprint_nebula_shellz.py,sha256=VjUjlDiEVkMhooRtItiU-0YzwksO6yyk2Sf1mVCKTSc,9750
-swarm/blueprints/omniplex/blueprint_omniplex.py,sha256=GuoxSbI05NzlDgtnUcHnqZhsxJ62FN2Y7SO2pbPhY_M,11486
+swarm/blueprints/monkai_magic/blueprint_monkai_magic.py,sha256=cx2hPbYcttOcvC4jfb6tExSUKiL4GMOHxuqzLtuSlso,14235
+swarm/blueprints/nebula_shellz/blueprint_nebula_shellz.py,sha256=d_b-5doQVLUMfoFMLeQfumVl09hr91JkuGTonLtrqi4,9917
+swarm/blueprints/omniplex/blueprint_omniplex.py,sha256=wbxTux_98dFjUSjzJNIhLDJMNlVfAfSUmlJjTJ9VQFs,12670
 swarm/blueprints/rue_code/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-swarm/blueprints/rue_code/blueprint_rue_code.py,sha256=Eh1MWT4m0_62WEVtgcijzTe_5kUUAUIvV7dB9BSqULo,14647
-swarm/blueprints/suggestion/blueprint_suggestion.py,sha256=nN9PqQJyDIa4lVHQluEviKZthsoKU4hejDUV4ed6KiA,5682
+swarm/blueprints/rue_code/blueprint_rue_code.py,sha256=28Eb_SDsvlnDC3SLNYHrKBpD6izTz53U-jqfZ6nqpto,15417
+swarm/blueprints/suggestion/blueprint_suggestion.py,sha256=hB7SWedDcc97LzVK56qEe7IufK_p5Ze-9H5TxXREGsE,7112
 swarm/blueprints/unapologetic_press/blueprint_unapologetic_press.py,sha256=e1-HpSHNp1PJAcb3-6sI1kE7KeJRQ2lGTUJPXYjvaY4,17648
 swarm/blueprints/whiskeytango_foxtrot/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 swarm/blueprints/whiskeytango_foxtrot/apps.py,sha256=V1QKvyb2Vz-EtDNhhNe4tw2W9LYhNDuiaIq_fAU4ilw,334
@@ -252,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.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,,
+open_swarm-0.1.1744936234.dist-info/METADATA,sha256=EVV17kQ_iNn0Xmnk7_VkMyLPBIWlbD08R6eDk3xQjko,13678
+open_swarm-0.1.1744936234.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+open_swarm-0.1.1744936234.dist-info/entry_points.txt,sha256=z1UIVRRhri-V-hWxFkDEYu0SZPUIsVO4KpDaodgcFzU,125
+open_swarm-0.1.1744936234.dist-info/licenses/LICENSE,sha256=BU9bwRlnOt_JDIb6OT55Q4leLZx9RArDLTFnlDIrBEI,1062
+open_swarm-0.1.1744936234.dist-info/RECORD,,

swarm/blueprints/digitalbutlers/blueprint_digitalbutlers.py

@@ -8,6 +8,8 @@ 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 # Added Runner
     from agents.mcp import MCPServer
@@ -61,6 +63,9 @@ gutenberg_instructions = (
 
 # --- Define the Blueprint ---
 class DigitalButlersBlueprint(BlueprintBase):
+    def __init__(self, blueprint_id: str, config_path: Optional[Path] = None, **kwargs):
+        super().__init__(blueprint_id, config_path=config_path, **kwargs)
+
     """Blueprint for private web search and home automation using a team of digital butlers."""
     metadata: ClassVar[Dict[str, Any]] = {
             "name": "DigitalButlersBlueprint",
@@ -178,6 +183,29 @@ class DigitalButlersBlueprint(BlueprintBase):
         logger.debug("Digital Butlers team created: Jeeves (Coordinator), Mycroft (Search), Gutenberg (Home).")
         return jeeves_agent # Jeeves is the entry point
 
+    async def run(self, messages: List[Dict[str, Any]], **kwargs) -> Any:
+        """Main execution entry point for the DigitalButlers blueprint."""
+        logger.info("DigitalButlersBlueprint 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("DigitalButlersBlueprint run method finished.")
+
+    async def _run_non_interactive(self, instruction: str, **kwargs) -> Any:
+        logger.info(f"Running DigitalButlers 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}"}]}
+
 # Standard Python entry point
 if __name__ == "__main__":
     DigitalButlersBlueprint.main()

swarm/blueprints/divine_code/blueprint_divine_code.py

@@ -8,6 +8,8 @@ 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
@@ -107,6 +109,9 @@ Available MCP Tools (if provided): sequential-thinking, filesystem.
 
 # --- Define the Blueprint ---
 class DivineOpsBlueprint(BlueprintBase):
+    def __init__(self, blueprint_id: str, config_path: Optional[Path] = None, **kwargs):
+        super().__init__(blueprint_id, config_path=config_path, **kwargs)
+
     """ Divine Ops: Streamlined Software Dev & Sysadmin Team Blueprint using openai-agents """
     metadata: ClassVar[Dict[str, Any]] = {
             "name": "DivineOpsBlueprint",
@@ -214,6 +219,27 @@ class DivineOpsBlueprint(BlueprintBase):
         logger.debug("Divine Ops Team (Zeus & Pantheon) created successfully. Zeus is starting agent.")
         return zeus_agent
 
+    async def run(self, messages: List[Dict[str, Any]], **kwargs) -> Any:
+        """Main execution entry point for the DivineOps blueprint."""
+        logger.info("DivineOpsBlueprint 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("DivineOpsBlueprint run method finished.")
+
+    async def _run_non_interactive(self, instruction: str, **kwargs) -> Any:
+        logger.info(f"Running DivineOps non-interactively with instruction: '{instruction[:100]}...'")
+        mcp_servers = kwargs.get("mcp_servers", [])
+        agent = self.create_starting_agent(mcp_servers=mcp_servers)
+        runner = Runner(agent=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
 if __name__ == "__main__":
     DivineOpsBlueprint.main()

swarm/blueprints/django_chat/blueprint_django_chat.py

@@ -10,11 +10,22 @@ import sys
 import os
 from typing import Dict, Any, List
 
+# --- Logging Setup ---
+def setup_logging():
+    import argparse
+    parser = argparse.ArgumentParser(add_help=False)
+    parser.add_argument('--debug', action='store_true', help='Enable debug logging')
+    args, _ = parser.parse_known_args()
+    loglevel = os.environ.get('LOGLEVEL', None)
+    if args.debug or os.environ.get('SWARM_DEBUG', '0') == '1' or (loglevel and loglevel.upper() == 'DEBUG'):
+        logging.basicConfig(level=logging.DEBUG)
+    else:
+        logging.basicConfig(level=logging.INFO)
+    return args
+
+args = setup_logging()
+
 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__":

swarm/blueprints/echocraft/blueprint_echocraft.py

@@ -1,6 +1,7 @@
-
 # --- Content for src/swarm/blueprints/echocraft/blueprint_echocraft.py ---
 import logging
+from typing import Optional
+from pathlib import Path
 from typing import List, Dict, Any, AsyncGenerator
 import uuid # Import uuid to generate IDs
 import time # Import time for timestamp
@@ -10,6 +11,9 @@ from swarm.extensions.blueprint.blueprint_base import BlueprintBase
 logger = logging.getLogger(__name__)
 
 class EchoCraftBlueprint(BlueprintBase):
+    def __init__(self, blueprint_id: str, config_path: Optional[Path] = None, **kwargs):
+        super().__init__(blueprint_id, config_path=config_path, **kwargs)
+
     """
     A simple blueprint that echoes the last user message.
     Used for testing and demonstrating basic blueprint structure.
@@ -27,6 +31,10 @@ class EchoCraftBlueprint(BlueprintBase):
         """
         logger.info(f"EchoCraftBlueprint run called with {len(messages)} messages.")
 
+        # Ensure LLM profile is initialized for test compatibility
+        if self._llm_profile_name is None:
+            self._llm_profile_name = self.config.get("llm_profile", "default")
+
         last_user_message_content = "No user message found."
         for msg in reversed(messages):
             if msg.get("role") == "user":
@@ -68,4 +76,3 @@ class EchoCraftBlueprint(BlueprintBase):
         # --- End formatting change ---
 
         logger.info("EchoCraftBlueprint run finished.")
-

swarm/blueprints/family_ties/blueprint_family_ties.py

@@ -8,6 +8,8 @@ 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
@@ -53,6 +55,9 @@ brian_instructions = (
 
 # --- 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
@@ -148,5 +153,28 @@ class FamilyTiesBlueprint(BlueprintBase):
         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__":
     FamilyTiesBlueprint.main()

swarm/blueprints/gaggle/blueprint_gaggle.py

@@ -1,6 +1,26 @@
 import logging
-import os # Added os import
+logging.basicConfig(level=logging.INFO, format='[%(levelname)s] %(name)s: %(message)s')
+import os
 import sys
+
+# --- Universal Logging Reset ---
+def force_info_logging():
+    root = logging.getLogger()
+    for handler in root.handlers[:]:
+        root.removeHandler(handler)
+    loglevel = os.environ.get('LOGLEVEL', None)
+    debug_env = os.environ.get('SWARM_DEBUG', '0') == '1'
+    debug_arg = '--debug' in sys.argv
+    if debug_arg or debug_env or (loglevel and loglevel.upper() == 'DEBUG'):
+        level = logging.DEBUG
+    else:
+        level = logging.INFO
+    logging.basicConfig(level=level, format='[%(levelname)s] %(name)s: %(message)s')
+    root.setLevel(level)
+
+force_info_logging()
+
+import argparse
 from typing import List, Dict, Any, Optional, ClassVar
 
 # Ensure src is in path for BlueprintBase import (if needed, adjust path)
@@ -8,6 +28,8 @@ 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
@@ -21,39 +43,66 @@ except ImportError as e:
     print(f"sys.path: {sys.path}")
     sys.exit(1)
 
+import argparse
+
+# --- Logging Setup ---
+def setup_logging():
+    parser = argparse.ArgumentParser(add_help=False)
+    parser.add_argument('--debug', action='store_true', help='Enable debug logging')
+    args, _ = parser.parse_known_args()
+    loglevel = os.environ.get('LOGLEVEL', None)
+    if args.debug or os.environ.get('SWARM_DEBUG', '0') == '1' or (loglevel and loglevel.upper() == 'DEBUG'):
+        logging.basicConfig(level=logging.DEBUG)
+    else:
+        logging.basicConfig(level=logging.INFO)
+    return args
+
+args = setup_logging()
+
 logger = logging.getLogger(__name__)
 
 # --- Tools ---
-@function_tool
-def create_story_outline(topic: str) -> str:
-    """Generates a basic story outline based on a topic."""
-    logger.info(f"Tool: Generating outline for: {topic}") # Keep INFO for tool exec start
-    # In a real scenario, this might involve more logic or an LLM call.
-    # Adding slight variation for clarity
+def _create_story_outline(topic: str) -> str:
+    logger.info(f"Tool: Generating outline for: {topic}")
     outline = f"Story Outline for '{topic}':\n1. Beginning: Introduce characters and setting.\n2. Middle: Develop conflict and rising action.\n3. Climax: The peak of the conflict.\n4. End: Resolution and aftermath."
     logger.debug(f"Generated outline: {outline}")
     return outline
 
 @function_tool
-def write_story_part(part_name: str, outline: str, previous_parts: str) -> str:
-    """Writes a specific part of the story using the outline and previous context."""
-    logger.info(f"Tool: Writing story part: {part_name}") # Keep INFO for tool exec start
-    # Simple placeholder implementation
+def create_story_outline(topic: str) -> str:
+    """Generates a basic story outline based on a topic."""
+    return _create_story_outline(topic)
+
+def _write_story_part(part_name: str, outline: str, previous_parts: str) -> str:
+    logger.info(f"Tool: Writing story part: {part_name}")
     content = f"## {part_name}\n\nThis is the draft content for the '{part_name}' section. It follows:\n'{previous_parts[:100]}...' \nIt should align with the outline:\n'{outline}'"
     logger.debug(f"Generated content for {part_name}: {content[:100]}...")
     return content
 
 @function_tool
-def edit_story(full_story: str, edit_instructions: str) -> str:
-    """Edits the complete story based on instructions."""
-    logger.info(f"Tool: Editing story with instructions: {edit_instructions}") # Keep INFO for tool exec start
-    # Simple placeholder for editing
+def write_story_part(part_name: str, outline: str, previous_parts: str) -> str:
+    """Writes a specific part of the story using the outline and previous context."""
+    return _write_story_part(part_name, outline, previous_parts)
+
+def _edit_story(full_story: str, edit_instructions: str) -> str:
+    logger.info(f"Tool: Editing story with instructions: {edit_instructions}")
     edited_content = f"*** Edited Story Draft ***\n(Based on instructions: '{edit_instructions}')\n\n{full_story}\n\n[Editor's Notes: Minor tweaks applied for flow.]"
     logger.debug("Editing complete.")
     return edited_content
 
+@function_tool
+def edit_story(full_story: str, edit_instructions: str) -> str:
+    """Edits the complete story based on instructions."""
+    return _edit_story(full_story, edit_instructions)
+
 # --- Blueprint Definition ---
+from rich.console import Console
+from rich.panel import Panel
+
 class GaggleBlueprint(BlueprintBase):
+    def __init__(self, blueprint_id: str, config_path: Optional[Path] = None, **kwargs):
+        super().__init__(blueprint_id, config_path=config_path, **kwargs)
+
     """A multi-agent blueprint using a Coordinator, Planner, Writer, and Editor for collaborative story writing."""
     metadata: ClassVar[Dict[str, Any]] = {
         "name": "GaggleBlueprint",
@@ -70,6 +119,23 @@ class GaggleBlueprint(BlueprintBase):
     _openai_client_cache: Dict[str, AsyncOpenAI] = {}
     _model_instance_cache: Dict[str, Model] = {}
 
+    def display_splash_screen(self, animated: bool = False):
+        console = Console()
+        splash = r'''
+[bold magenta]
+   ____                   _      _      ____  _             _
+  / ___| __ _ _ __   __ _| | ___| |__  / ___|| |_ __ _ _ __| |_ ___
+ | |  _ / _` | '_ \ / _` | |/ _ \ '_ \ \___ \| __/ _` | '__| __/ _ \
+ | |_| | (_| | | | | (_| | |  __/ | | | ___) | || (_| | |  | ||  __/
+  \____|\__,_|_| |_|\__, |_|\___|_| |_|____/ \__\__,_|_|   \__\___|
+                   |___/
+[/bold magenta]
+[white]Collaborative Story Writing Blueprint[/white]
+'''
+        panel = Panel(splash, title="[bold magenta]Gaggle Blueprint[/]", border_style="magenta", expand=False)
+        console.print(panel)
+        console.print() # Blank line for spacing
+
     # --- Model Instantiation Helper --- (Standard helper)
     def _get_model_instance(self, profile_name: str) -> Model:
         """Retrieves or creates an LLM Model instance."""
@@ -180,5 +246,41 @@ class GaggleBlueprint(BlueprintBase):
         logger.debug("Gaggle Story Writing Team created. Coordinator is the starting agent.")
         return coordinator_agent
 
+    async def run(self, messages: List[Dict[str, str]]):
+        """
+        Run the Gaggle blueprint agentic workflow.
+        Accepts a list of messages (e.g., task prompt from CLI) and yields output chunks.
+        """
+        # For demonstration, this will run the collaborative story workflow
+        topic = None
+        for msg in messages:
+            if msg.get("role") == "user":
+                topic = msg.get("content")
+                break
+        if not topic:
+            yield {"messages": [{"role": "system", "content": "No topic provided."}]}
+            return
+        # Step 1: Planner creates outline
+        outline = _create_story_outline(topic)
+        yield {"messages": [{"role": "planner", "content": outline}]}
+        # Step 2: Writer writes story parts (simulate parts)
+        story_parts = []
+        for part in ["Beginning", "Middle", "Climax", "End"]:
+            part_text = _write_story_part(part, outline, "\n".join(story_parts))
+            story_parts.append(part_text)
+            yield {"messages": [{"role": "writer", "content": part_text}]}
+        # Step 3: Editor edits the full story
+        full_story = "\n\n".join(story_parts)
+        edited = _edit_story(full_story, "Polish for flow and clarity.")
+        yield {"messages": [{"role": "editor", "content": edited}]}
+
+    async def _run_non_interactive(self, instruction: str, **kwargs):
+        """Adapter for CLI non-interactive execution, yields results from the public run method. Accepts **kwargs for compatibility."""
+        messages = [{"role": "user", "content": instruction}]
+        async for chunk in self.run(messages, **kwargs):
+            yield chunk
+
+
+
 if __name__ == "__main__":
     GaggleBlueprint.main()

swarm/blueprints/monkai_magic/blueprint_monkai_magic.py

@@ -116,6 +116,16 @@ def vercel_cli(command: str) -> str:
 
 
 # --- Define the Blueprint ---
+# === OpenAI GPT-4.1 Prompt Engineering Guide ===
+# See: https://github.com/openai/openai-cookbook/blob/main/examples/gpt4-1_prompting_guide.ipynb
+#
+# Agentic System Prompt Example (recommended for cloud ops agents):
+SYS_PROMPT_AGENTIC = """
+You are an agent - please keep going until the user’s query is completely resolved, before ending your turn and yielding back to the user. Only terminate your turn when you are sure that the problem is solved.
+If you are not sure about file content or codebase structure pertaining to the user’s request, use your tools to read files and gather the relevant information: do NOT guess or make up an answer.
+You MUST plan extensively before each function call, and reflect extensively on the outcomes of the previous function calls. DO NOT do this entire process by making function calls only, as this can impair your ability to solve the problem and think insightfully.
+"""
+
 class MonkaiMagicBlueprint(BlueprintBase):
     """Blueprint for a cloud operations team inspired by *Monkai Magic*."""
     metadata: ClassVar[Dict[str, Any]] = {

swarm/blueprints/nebula_shellz/blueprint_nebula_shellz.py

@@ -59,6 +59,13 @@ cypher_instructions = "You are Cypher..."
 tank_instructions = "You are Tank..."
 
 # --- Blueprint Definition ---
+from rich.console import Console
+from rich.panel import Panel
+from rich.live import Live
+from rich.text import Text
+import random
+import time
+
 class NebuchaShellzzarBlueprint(BlueprintBase):
     """A multi-agent blueprint inspired by The Matrix for sysadmin and coding tasks."""
     metadata: ClassVar[Dict[str, Any]] = {
@@ -68,22 +75,46 @@ class NebuchaShellzzarBlueprint(BlueprintBase):
         "tags": ["matrix", "multi-agent", "shell", "coding", "mcp"],
         "required_mcp_servers": ["memory"],
     }
-    _openai_client_cache: Dict[str, AsyncOpenAI] = {}
     _model_instance_cache: Dict[str, Model] = {}
 
     # --- ADDED: Splash Screen ---
-    def display_splash_screen(self):
-        """Displays a Matrix-themed splash screen."""
-        splash_text = """
+    def display_splash_screen(self, animated: bool = False):
+        console = Console()
+        if not animated:
+            splash_text = """
 [bold green]Wake up, Neo...[/]
 [green]The Matrix has you...[/]
 [bold green]Follow the white rabbit.[/]
 
 Initializing NebulaShellzzar Crew...
-        """
-        panel = Panel(splash_text.strip(), title="[bold green]NebulaShellzzar[/]", border_style="green", expand=False)
-        self.console.print(panel)
-        self.console.print() # Add a blank line
+            """
+            panel = Panel(splash_text.strip(), title="[bold green]NebulaShellzzar[/]", border_style="green", expand=False)
+            console.print(panel)
+            console.print() # Add a blank line
+        else:
+            # Animated Matrix rain effect
+            width = 60
+            height = 12
+            charset = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789@#$%&"
+            rain_cols = [0] * width
+            with Live(refresh_per_second=20, console=console, transient=True) as live:
+                for _ in range(30):
+                    matrix = ""
+                    for y in range(height):
+                        line = ""
+                        for x in range(width):
+                            if random.random() < 0.02:
+                                rain_cols[x] = 0
+                            char = random.choice(charset) if rain_cols[x] < y else " "
+                            line += f"[green]{char}[/]"
+                        matrix += line + "\n"
+                    panel = Panel(Text.from_markup(matrix), title="[bold green]NebulaShellzzar[/]", border_style="green", expand=False)
+                    live.update(panel)
+                    time.sleep(0.07)
+            console.print("[bold green]Wake up, Neo...[/]")
+            console.print("[green]The Matrix has you...[/]")
+            console.print("[bold green]Follow the white rabbit.[/]")
+            console.print("\nInitializing NebulaShellzzar Crew...\n")
 
     def _get_model_instance(self, profile_name: str) -> Model:
         """Gets or creates a Model instance for the given profile name."""
@@ -100,26 +131,14 @@ Initializing NebulaShellzzar Crew...
         if not model_name:
              logger.critical(f"LLM profile '{profile_name}' is missing the 'model' key.")
              raise ValueError(f"Missing 'model' key in LLM profile '{profile_name}'.")
-        client_cache_key = f"{provider}_{profile_data.get('base_url')}"
-        if provider == "openai":
-            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}") # Changed to DEBUG
-                 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 specific client instance.")
-            try: model_instance = OpenAIChatCompletionsModel(model=model_name, openai_client=openai_client_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
-        else:
-            logger.error(f"Unsupported LLM provider '{provider}' in profile '{profile_name}'.")
-            raise ValueError(f"Unsupported LLM provider: {provider}")
+
+        # Remove redundant client instantiation; rely on framework-level default client
+        # All blueprints now use the default client set at framework init
+        logger.debug(f"Instantiating OpenAIChatCompletionsModel(model='{model_name}') with default client.")
+        try: model_instance = OpenAIChatCompletionsModel(model=model_name)
+        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
         self._model_instance_cache[profile_name] = model_instance
         return model_instance
 
@@ -127,7 +146,6 @@ Initializing NebulaShellzzar Crew...
         """Creates the Matrix-themed agent team with Morpheus as the coordinator."""
         logger.debug(f"Creating NebulaShellzzar agent team with {len(mcp_servers)} MCP server(s)...") # Changed to DEBUG
         self._model_instance_cache = {}
-        self._openai_client_cache = {}
         default_profile_name = self.config.get("llm_profile", "default")
         default_model_instance = self._get_model_instance(default_profile_name)
         logger.debug(f"Using LLM profile '{default_profile_name}' for all agents.") # Changed to DEBUG

swarm/blueprints/omniplex/blueprint_omniplex.py

@@ -216,6 +216,27 @@ class OmniplexBlueprint(BlueprintBase):
         logger.info(f"Omniplex Coordinator created with tools for: {[t.name for t in team_tools]}")
         return coordinator_agent
 
+    async def run(self, messages: List[Dict[str, Any]], **kwargs) -> Any:
+        """Main execution entry point for the Omniplex blueprint."""
+        logger.info("OmniplexBlueprint 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("OmniplexBlueprint run method finished.")
+
+    async def _run_non_interactive(self, instruction: str, **kwargs) -> Any:
+        logger.info(f"Running OmniplexBlueprint non-interactively with instruction: '{instruction[:100]}...'")
+        mcp_servers = kwargs.get("mcp_servers", [])
+        agent = self.create_starting_agent(mcp_servers=mcp_servers)
+        from agents import Runner
+        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}"}]}
+
 # Standard Python entry point
 if __name__ == "__main__":
     OmniplexBlueprint.main()

swarm/blueprints/rue_code/blueprint_rue_code.py

@@ -57,51 +57,41 @@ def execute_shell_command(command: str) -> str:
 
 def read_file(file_path: str) -> str:
     """Reads the content of a specified file."""
-    logger.info(f"Reading file: {file_path}")
+    logger.info(f"📄 Reading file: {file_path}")
     try:
-        # Basic path traversal check (can be enhanced)
         if ".." in file_path:
-             logger.warning(f"Attempted path traversal detected in read_file: {file_path}")
-             return "Error: Invalid file path (potential traversal)."
-        # Consider restricting base path if needed
-        # base_path = Path("/workspace").resolve()
-        # target_path = (base_path / file_path).resolve()
-        # if not target_path.is_relative_to(base_path):
-        #     return "Error: Access denied."
-
+            logger.warning(f"Attempted path traversal detected in read_file: {file_path}")
+            return "\033[91m❌ Error: Invalid file path (potential traversal).\033[0m"
         path = Path(file_path)
         if not path.is_file():
-            return f"Error: File not found at {file_path}"
+            logger.warning(f"File not found: {file_path}")
+            return f"\033[91m❌ Error: File not found at {file_path}\033[0m"
         content = path.read_text(encoding='utf-8')
         logger.info(f"Successfully read {len(content)} characters from {file_path}")
-        # Truncate long files?
         max_len = 10000
         if len(content) > max_len:
-             logger.warning(f"File {file_path} truncated to {max_len} characters.")
-             return content[:max_len] + "\n... [File Truncated]"
-        return content
+            logger.warning(f"File {file_path} truncated to {max_len} characters.")
+            return f"\033[93m⚠️ {content[:max_len]}\n... [File Truncated]\033[0m"
+        return f"\033[92m✅ File read successfully!\033[0m\n\033[94m{content}\033[0m"
     except Exception as e:
         logger.error(f"Error reading file '{file_path}': {e}", exc_info=True)
-        return f"Error reading file: {e}"
+        return f"\033[91m❌ Error reading file: {e}\033[0m"
 
 def write_file(file_path: str, content: str) -> str:
     """Writes content to a specified file, creating directories if needed."""
-    logger.info(f"Writing to file: {file_path}")
+    logger.info(f"✏️ Writing to file: {file_path}")
     try:
-        # Basic path traversal check
         if ".." in file_path:
-             logger.warning(f"Attempted path traversal detected in write_file: {file_path}")
-             return "Error: Invalid file path (potential traversal)."
-        # Consider restricting base path
-
+            logger.warning(f"Attempted path traversal detected in write_file: {file_path}")
+            return "\033[91m❌ Error: Invalid file path (potential traversal).\033[0m"
         path = Path(file_path)
         path.parent.mkdir(parents=True, exist_ok=True)
         path.write_text(content, encoding='utf-8')
         logger.info(f"Successfully wrote {len(content)} characters to {file_path}")
-        return f"Successfully wrote to {file_path}"
+        return f"\033[92m✅ Successfully wrote to {file_path}\033[0m"
     except Exception as e:
         logger.error(f"Error writing file '{file_path}': {e}", exc_info=True)
-        return f"Error writing file: {e}"
+        return f"\033[91m❌ Error writing file: {e}\033[0m"
 
 def list_files(directory_path: str = ".") -> str:
     """Lists files and directories in a specified path."""
@@ -130,6 +120,16 @@ def list_files(directory_path: str = ".") -> str:
 
 # --- RueCodeBlueprint Definition ---
 
+# === OpenAI GPT-4.1 Prompt Engineering Guide ===
+# See: https://github.com/openai/openai-cookbook/blob/main/examples/gpt4-1_prompting_guide.ipynb
+#
+# Agentic System Prompt Example (recommended for code generation/repair agents):
+SYS_PROMPT_AGENTIC = """
+You are an agent - please keep going until the user’s query is completely resolved, before ending your turn and yielding back to the user. Only terminate your turn when you are sure that the problem is solved.
+If you are not sure about file content or codebase structure pertaining to the user’s request, use your tools to read files and gather the relevant information: do NOT guess or make up an answer.
+You MUST plan extensively before each function call, and reflect extensively on the outcomes of the previous function calls. DO NOT do this entire process by making function calls only, as this can impair your ability to solve the problem and think insightfully.
+"""
+
 class RueCodeBlueprint(BlueprintBase):
     """
     A blueprint designed for code generation, execution, and file system interaction.
@@ -288,4 +288,3 @@ class RueCodeBlueprint(BlueprintBase):
             yield {"messages": [{"role": "assistant", "content": f"An error occurred: {e}"}]}
 
         logger.info("RueCodeBlueprint run finished.")
-

swarm/blueprints/suggestion/blueprint_suggestion.py

@@ -27,6 +27,16 @@ class SuggestionsOutput(TypedDict):
     suggestions: List[str]
 
 # --- Define the Blueprint ---
+# === OpenAI GPT-4.1 Prompt Engineering Guide ===
+# See: https://github.com/openai/openai-cookbook/blob/main/examples/gpt4-1_prompting_guide.ipynb
+#
+# Agentic System Prompt Example (recommended for structured output/suggestion agents):
+SYS_PROMPT_AGENTIC = """
+You are an agent - please keep going until the user’s query is completely resolved, before ending your turn and yielding back to the user. Only terminate your turn when you are sure that the problem is solved.
+If you are not sure about file content or codebase structure pertaining to the user’s request, use your tools to read files and gather the relevant information: do NOT guess or make up an answer.
+You MUST plan extensively before each function call, and reflect extensively on the outcomes of the previous function calls. DO NOT do this entire process by making function calls only, as this can impair your ability to solve the problem and think insightfully.
+"""
+
 class SuggestionBlueprint(BlueprintBase):
     """A blueprint defining an agent that generates structured JSON suggestions using output_type."""
 
@@ -42,7 +52,6 @@ class SuggestionBlueprint(BlueprintBase):
     }
 
     # Caches
-    _openai_client_cache: Dict[str, AsyncOpenAI] = {}
     _model_instance_cache: Dict[str, Model] = {}
 
     # --- Model Instantiation Helper --- (Standard helper)
@@ -61,19 +70,12 @@ class SuggestionBlueprint(BlueprintBase):
         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]
+        # Remove redundant client instantiation; rely on framework-level default client
+        # All blueprints now use the default client set at framework init
         logger.debug(f"Instantiating OpenAIChatCompletionsModel(model='{model_name}') for '{profile_name}'.")
         try:
             # Ensure the model selected supports structured output (most recent OpenAI do)
-            model_instance = OpenAIChatCompletionsModel(model=model_name, openai_client=client)
+            model_instance = OpenAIChatCompletionsModel(model=model_name)
             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
@@ -82,7 +84,6 @@ class SuggestionBlueprint(BlueprintBase):
         """Create the SuggestionAgent."""
         logger.debug("Creating SuggestionAgent...")
         self._model_instance_cache = {}
-        self._openai_client_cache = {}
 
         default_profile_name = self.config.get("llm_profile", "default")
         # Verify the chosen profile/model supports structured output if possible, or rely on OpenAI's newer models
@@ -106,5 +107,27 @@ class SuggestionBlueprint(BlueprintBase):
         logger.debug("SuggestionAgent created with output_type enforcement.")
         return suggestion_agent
 
+    async def run(self, messages: List[Dict[str, Any]], **kwargs) -> Any:
+        """Main execution entry point for the Suggestion blueprint."""
+        logger.info("SuggestionBlueprint 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("SuggestionBlueprint run method finished.")
+
+    async def _run_non_interactive(self, instruction: str, **kwargs) -> Any:
+        logger.info(f"Running SuggestionBlueprint non-interactively with instruction: '{instruction[:100]}...'")
+        mcp_servers = kwargs.get("mcp_servers", [])
+        agent = self.create_starting_agent(mcp_servers=mcp_servers)
+        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__":
     SuggestionBlueprint.main()