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

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()

swarm/consumers.py

@@ -62,6 +62,25 @@ class DjangoChatConsumer(AsyncWebsocketConsumer):
         await self.send(text_data=system_message_html)
 
         client = AsyncOpenAI(api_key=os.getenv("OPENAI_API_KEY"))
+        
+        # --- PATCH: Enforce LiteLLM-only endpoint and suppress OpenAI tracing/telemetry ---
+        import os, logging
+        if os.environ.get("LITELLM_BASE_URL") or os.environ.get("OPENAI_BASE_URL"):
+            logging.getLogger("openai.agents").setLevel(logging.CRITICAL)
+            try:
+                import openai.agents.tracing
+                openai.agents.tracing.TracingClient = lambda *a, **kw: None
+            except Exception:
+                pass
+        def _enforce_litellm_only(client):
+            base_url = getattr(client, 'base_url', None)
+            if base_url and 'openai.com' in base_url:
+                return
+            if base_url and 'openai.com' not in base_url:
+                import traceback
+                raise RuntimeError(f"Attempted fallback to OpenAI API when custom base_url is set! base_url={base_url}\n{traceback.format_stack()}")
+        _enforce_litellm_only(client)
+        
         stream = await client.chat.completions.create(
             model=os.getenv("OPENAI_MODEL"),
             messages=self.messages,

swarm/extensions/blueprint/agent_utils.py

@@ -6,7 +6,7 @@ This module has been updated to remove dependency on swarm.types;
 instead, it now imports Agent from the openai-agents SDK.
 """
 
-from agents.agent import Agent  # Updated import
+from blueprint_agents.agent import Agent  # Updated import
 
 def get_agent_name(agent: Agent) -> str:
     """