open-swarm 0.1.1744936125__tar.gz → 0.1.1744936234__tar.gz

{open_swarm-0.1.1744936125 → open_swarm-0.1.1744936234}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: open-swarm
-Version: 0.1.1744936125
+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.1744936125 → open_swarm-0.1.1744936234}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "open-swarm"
-version = "0.1.1744936125"
+version = "0.1.1744936234"
 description = "Open Swarm: Orchestrating AI Agent Swarms with Django"
 readme = "README.md"
 requires-python = ">=3.10"

{open_swarm-0.1.1744936125 → open_swarm-0.1.1744936234}/src/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()

{open_swarm-0.1.1744936125 → open_swarm-0.1.1744936234}/src/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()

{open_swarm-0.1.1744936125 → open_swarm-0.1.1744936234}/src/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__":

{open_swarm-0.1.1744936125 → open_swarm-0.1.1744936234}/src/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.")
-

{open_swarm-0.1.1744936125 → open_swarm-0.1.1744936234}/src/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()

{open_swarm-0.1.1744936125 → open_swarm-0.1.1744936234}/src/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()

{open_swarm-0.1.1744936125 → open_swarm-0.1.1744936234}/src/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]] = {

{open_swarm-0.1.1744936125 → open_swarm-0.1.1744936234}/src/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

{open_swarm-0.1.1744936125 → open_swarm-0.1.1744936234}/src/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()