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

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

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

@@ -14,8 +14,8 @@ swarm/util.py,sha256=G4x2hXopHhB7IdGCkUXGoykYWyiICnjxg7wcr-WqL8I,4644
 swarm/wsgi.py,sha256=REM_u4HpMCkO0ddrOUXgtY-ITL-VTbRB1-WHvFJAtAU,408
 swarm/agent/__init__.py,sha256=YESGu_UXEBxrlQwghodUMN0vmXZDwWMU7DclCUvoklA,104
 swarm/blueprints/README.md,sha256=tsngbSB9N0tILcz_m1OGAjyKZQYlGTN-i5e5asq1GbE,8478
-swarm/blueprints/burnt_noodles/blueprint_burnt_noodles.py,sha256=MDwjlA4HQ6GFh7Z-XGM0Wdh0FzQdOHf38p3Y580EgWM,23008
-swarm/blueprints/chatbot/blueprint_chatbot.py,sha256=D31OgSoxllhzn8f7cdVYflqzadN2SZ61rabPuK6EqQ8,4728
+swarm/blueprints/burnt_noodles/blueprint_burnt_noodles.py,sha256=vopDlBjVUNeSq6WItdkmtWJfObgbtL6wNAy2njsskkY,19607
+swarm/blueprints/chatbot/blueprint_chatbot.py,sha256=a5-gIyDvRtNgbyfviD9Hua9r5NjOQh1lOafIG2a6kiI,7520
 swarm/blueprints/chatbot/templates/chatbot/chatbot.html,sha256=REFnqNg0EHsXxAUfaCJe1YgOKiV_umBXuC6y8veF5CU,1568
 swarm/blueprints/digitalbutlers/blueprint_digitalbutlers.py,sha256=JK_rmZgPMw4PdQFrMverrwgcjH0NRkuqkchYOJwXYuM,9809
 swarm/blueprints/dilbot_universe/blueprint_dilbot_universe.py,sha256=w7i96KkRNmBOV2Kz9SJqQCirsRPEgENR-79iLOzpKaQ,16770
@@ -63,6 +63,7 @@ swarm/extensions/blueprint/config_loader.py,sha256=ldQGtv4tXeDJzL2GCylDxykZxYBo4
 swarm/extensions/blueprint/django_utils.py,sha256=ObtkmF1JW4H2OEYa7vC6ussUsMBtDsZTTVeHGHI-GOQ,17457
 swarm/extensions/blueprint/interactive_mode.py,sha256=vGmMuAgC93TLjMi2RkXQ2FkWfIUblyOTFGHmVdGKLSQ,4572
 swarm/extensions/blueprint/output_utils.py,sha256=8OtVE3gEvPeeTu4Juo6Ad6omSlMqSuAtckXXx7P1CyQ,4022
+swarm/extensions/blueprint/runnable_blueprint.py,sha256=1MywZ54vUysLVtYmwCbcDYQmQnoZffCHgsArbe-VKe8,1813
 swarm/extensions/blueprint/spinner.py,sha256=3J0ZrNzoI5O5qR7hnCeRM3dZx2fLb_H3zkoj_AYt5LQ,3394
 swarm/extensions/blueprint/modes/rest_mode.py,sha256=KZuB_j2NfomER7CmlsLBqRipU3DymKY-9RpoGilMH0I,1357
 swarm/extensions/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -254,8 +255,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.1743416034.dist-info/METADATA,sha256=rUCsvDnHgcapfgloeHA_QOGi2DbDGlxMKwHY5g_xPSM,13678
-open_swarm-0.1.1743416034.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-open_swarm-0.1.1743416034.dist-info/entry_points.txt,sha256=z1UIVRRhri-V-hWxFkDEYu0SZPUIsVO4KpDaodgcFzU,125
-open_swarm-0.1.1743416034.dist-info/licenses/LICENSE,sha256=BU9bwRlnOt_JDIb6OT55Q4leLZx9RArDLTFnlDIrBEI,1062
-open_swarm-0.1.1743416034.dist-info/RECORD,,
+open_swarm-0.1.1744936125.dist-info/METADATA,sha256=ddaFDVixx5XyE42kg6sn5ZIcFcy7rbfO-z-bl5QpIbI,13678
+open_swarm-0.1.1744936125.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+open_swarm-0.1.1744936125.dist-info/entry_points.txt,sha256=z1UIVRRhri-V-hWxFkDEYu0SZPUIsVO4KpDaodgcFzU,125
+open_swarm-0.1.1744936125.dist-info/licenses/LICENSE,sha256=BU9bwRlnOt_JDIb6OT55Q4leLZx9RArDLTFnlDIrBEI,1062
+open_swarm-0.1.1744936125.dist-info/RECORD,,

swarm/blueprints/burnt_noodles/blueprint_burnt_noodles.py

@@ -7,7 +7,7 @@ import shlex # Added for safe command splitting
 import re
 import inspect
 from pathlib import Path # Use pathlib for better path handling
-from typing import Dict, Any, List, Optional, ClassVar
+from typing import Dict, Any, List, Optional, ClassVar, AsyncGenerator
 
 try:
     # Core imports from openai-agents
@@ -30,191 +30,111 @@ except ImportError as e:
 logger = logging.getLogger(__name__)
 # Logging level is controlled by BlueprintBase based on --debug flag
 
-# --- Tool Definitions ---
-# Standalone functions decorated as tools for git and testing operations.
-# Enhanced error handling and logging added.
-
-@function_tool
-def git_status() -> str:
+# --- Tool Logic Definitions (Undecorated) ---
+def _git_status_logic() -> str:
     """Executes 'git status --porcelain' and returns the current repository status."""
-    logger.info("Executing git status --porcelain") # Keep INFO for tool execution start
+    logger.info("Executing git status --porcelain")
     try:
-        # Using --porcelain for machine-readable output
         result = subprocess.run(["git", "status", "--porcelain"], capture_output=True, text=True, check=True, timeout=30)
         output = result.stdout.strip()
         logger.debug(f"Git status raw output:\n{output}")
         return f"OK: Git Status:\n{output}" if output else "OK: No changes detected in the working directory."
-    except FileNotFoundError:
-        logger.error("Git command not found. Is git installed and in PATH?")
-        return "Error: git command not found."
-    except subprocess.CalledProcessError as e:
-        logger.error(f"Error executing git status: {e.stderr}")
-        return f"Error executing git status: {e.stderr}"
-    except subprocess.TimeoutExpired:
-        logger.error("Git status command timed out.")
-        return "Error: Git status command timed out."
-    except Exception as e:
-        logger.error(f"Unexpected error during git status: {e}", exc_info=logger.level <= logging.DEBUG)
-        return f"Error during git status: {e}"
-@function_tool
-def git_diff() -> str:
+    except FileNotFoundError: logger.error("Git command not found."); return "Error: git command not found."
+    except subprocess.CalledProcessError as e: logger.error(f"Error executing git status: {e.stderr}"); return f"Error executing git status: {e.stderr}"
+    except subprocess.TimeoutExpired: logger.error("Git status command timed out."); return "Error: Git status command timed out."
+    except Exception as e: logger.error(f"Unexpected error during git status: {e}", exc_info=logger.level <= logging.DEBUG); return f"Error during git status: {e}"
+
+def _git_diff_logic() -> str:
     """Executes 'git diff' and returns the differences in the working directory."""
-    logger.info("Executing git diff") # Keep INFO for tool execution start
+    logger.info("Executing git diff")
     try:
-        result = subprocess.run(["git", "diff"], capture_output=True, text=True, check=False, timeout=30) # Use check=False, handle exit code
-        output = result.stdout
-        stderr = result.stderr.strip()
-        if result.returncode != 0 and stderr: # Error occurred
-            logger.error(f"Error executing git diff (Exit Code {result.returncode}): {stderr}")
-            return f"Error executing git diff: {stderr}"
-        logger.debug(f"Git diff raw output (Exit Code {result.returncode}):\n{output[:1000]}...") # Log snippet
+        result = subprocess.run(["git", "diff"], capture_output=True, text=True, check=False, timeout=30)
+        output = result.stdout; stderr = result.stderr.strip()
+        if result.returncode != 0 and stderr: logger.error(f"Error executing git diff (Exit Code {result.returncode}): {stderr}"); return f"Error executing git diff: {stderr}"
+        logger.debug(f"Git diff raw output (Exit Code {result.returncode}):\n{output[:1000]}...")
         return f"OK: Git Diff Output:\n{output}" if output else "OK: No differences found."
-    except FileNotFoundError:
-        logger.error("Git command not found.")
-        return "Error: git command not found."
-    except subprocess.TimeoutExpired:
-        logger.error("Git diff command timed out.")
-        return "Error: Git diff command timed out."
-    except Exception as e:
-        logger.error(f"Unexpected error during git diff: {e}", exc_info=logger.level <= logging.DEBUG)
-        return f"Error during git diff: {e}"
+    except FileNotFoundError: logger.error("Git command not found."); return "Error: git command not found."
+    except subprocess.TimeoutExpired: logger.error("Git diff command timed out."); return "Error: Git diff command timed out."
+    except Exception as e: logger.error(f"Unexpected error during git diff: {e}", exc_info=logger.level <= logging.DEBUG); return f"Error during git diff: {e}"
 
-@function_tool
-def git_add(file_path: str = ".") -> str:
+def _git_add_logic(file_path: str = ".") -> str:
     """Executes 'git add' to stage changes for the specified file or all changes (default '.')."""
-    logger.info(f"Executing git add {file_path}") # Keep INFO for tool execution start
+    logger.info(f"Executing git add {file_path}")
     try:
         result = subprocess.run(["git", "add", file_path], capture_output=True, text=True, check=True, timeout=30)
         logger.debug(f"Git add '{file_path}' completed successfully.")
         return f"OK: Staged '{file_path}' successfully."
-    except FileNotFoundError:
-        logger.error("Git command not found.")
-        return "Error: git command not found."
-    except subprocess.CalledProcessError as e:
-        logger.error(f"Error executing git add '{file_path}': {e.stderr}")
-        return f"Error executing git add '{file_path}': {e.stderr}"
-    except subprocess.TimeoutExpired:
-        logger.error(f"Git add command timed out for '{file_path}'.")
-        return f"Error: Git add command timed out for '{file_path}'."
-    except Exception as e:
-        logger.error(f"Unexpected error during git add '{file_path}': {e}", exc_info=logger.level <= logging.DEBUG)
-        return f"Error during git add '{file_path}': {e}"
+    except FileNotFoundError: logger.error("Git command not found."); return "Error: git command not found."
+    except subprocess.CalledProcessError as e: logger.error(f"Error executing git add '{file_path}': {e.stderr}"); return f"Error executing git add '{file_path}': {e.stderr}"
+    except subprocess.TimeoutExpired: logger.error(f"Git add command timed out for '{file_path}'."); return f"Error: Git add command timed out for '{file_path}'."
+    except Exception as e: logger.error(f"Unexpected error during git add '{file_path}': {e}", exc_info=logger.level <= logging.DEBUG); return f"Error during git add '{file_path}': {e}"
 
-@function_tool
-def git_commit(message: str) -> str:
+def _git_commit_logic(message: str) -> str:
     """Executes 'git commit' with a provided commit message."""
-    logger.info(f"Executing git commit -m '{message[:50]}...'") # Keep INFO for tool execution start
-    if not message or not message.strip():
-        logger.warning("Git commit attempted with empty or whitespace-only message.")
-        return "Error: Commit message cannot be empty."
+    logger.info(f"Executing git commit -m '{message[:50]}...'")
+    if not message or not message.strip(): logger.warning("Git commit attempted with empty message."); return "Error: Commit message cannot be empty."
     try:
-        # Using list form is generally safer than shell=True for complex args
-        result = subprocess.run(["git", "commit", "-m", message], capture_output=True, text=True, check=False, timeout=30) # Use check=False
-        output = result.stdout.strip()
-        stderr = result.stderr.strip()
+        result = subprocess.run(["git", "commit", "-m", message], capture_output=True, text=True, check=False, timeout=30)
+        output = result.stdout.strip(); stderr = result.stderr.strip()
         logger.debug(f"Git commit raw output (Exit Code {result.returncode}):\nSTDOUT: {output}\nSTDERR: {stderr}")
-
-        # Handle common non-error cases explicitly
         if "nothing to commit" in output or "nothing added to commit" in output or "no changes added to commit" in output:
-             logger.info("Git commit reported: Nothing to commit.")
-             return "OK: Nothing to commit."
-        if result.returncode == 0:
-            return f"OK: Committed with message '{message}'.\n{output}"
-        else:
-            # Log specific error if available
-            error_detail = stderr if stderr else output
-            logger.error(f"Error executing git commit (Exit Code {result.returncode}): {error_detail}")
-            return f"Error executing git commit: {error_detail}"
-
-    except FileNotFoundError:
-        logger.error("Git command not found.")
-        return "Error: git command not found."
-    except subprocess.TimeoutExpired:
-        logger.error("Git commit command timed out.")
-        return "Error: Git commit command timed out."
-    except Exception as e:
-        logger.error(f"Unexpected error during git commit: {e}", exc_info=logger.level <= logging.DEBUG)
-        return f"Error during git commit: {e}"
+             logger.info("Git commit reported: Nothing to commit."); return "OK: Nothing to commit."
+        if result.returncode == 0: return f"OK: Committed with message '{message}'.\n{output}"
+        else: error_detail = stderr if stderr else output; logger.error(f"Error executing git commit (Exit Code {result.returncode}): {error_detail}"); return f"Error executing git commit: {error_detail}"
+    except FileNotFoundError: logger.error("Git command not found."); return "Error: git command not found."
+    except subprocess.TimeoutExpired: logger.error("Git commit command timed out."); return "Error: Git commit command timed out."
+    except Exception as e: logger.error(f"Unexpected error during git commit: {e}", exc_info=logger.level <= logging.DEBUG); return f"Error during git commit: {e}"
 
-@function_tool
-def git_push() -> str:
+def _git_push_logic() -> str:
     """Executes 'git push' to push staged commits to the remote repository."""
-    logger.info("Executing git push") # Keep INFO for tool execution start
+    logger.info("Executing git push")
     try:
-        result = subprocess.run(["git", "push"], capture_output=True, text=True, check=True, timeout=120) # Longer timeout for push
-        output = result.stdout.strip() + "\n" + result.stderr.strip() # Combine stdout/stderr
+        result = subprocess.run(["git", "push"], capture_output=True, text=True, check=True, timeout=120)
+        output = result.stdout.strip() + "\n" + result.stderr.strip()
         logger.debug(f"Git push raw output:\n{output}")
         return f"OK: Push completed.\n{output.strip()}"
-    except FileNotFoundError:
-        logger.error("Git command not found.")
-        return "Error: git command not found."
-    except subprocess.CalledProcessError as e:
-        error_output = e.stdout.strip() + "\n" + e.stderr.strip()
-        logger.error(f"Error executing git push: {error_output}")
-        return f"Error executing git push: {error_output.strip()}"
-    except subprocess.TimeoutExpired:
-        logger.error("Git push command timed out.")
-        return "Error: Git push command timed out."
-    except Exception as e:
-        logger.error(f"Unexpected error during git push: {e}", exc_info=logger.level <= logging.DEBUG)
-        return f"Error during git push: {e}"
+    except FileNotFoundError: logger.error("Git command not found."); return "Error: git command not found."
+    except subprocess.CalledProcessError as e: error_output = e.stdout.strip() + "\n" + e.stderr.strip(); logger.error(f"Error executing git push: {error_output}"); return f"Error executing git push: {error_output.strip()}"
+    except subprocess.TimeoutExpired: logger.error("Git push command timed out."); return "Error: Git push command timed out."
+    except Exception as e: logger.error(f"Unexpected error during git push: {e}", exc_info=logger.level <= logging.DEBUG); return f"Error during git push: {e}"
 
-@function_tool
-def run_npm_test(args: str = "") -> str:
+def _run_npm_test_logic(args: str = "") -> str:
     """Executes 'npm run test' with optional arguments."""
     try:
-        # Use shlex.split for safer argument handling if args are provided
-        cmd_list = ["npm", "run", "test"] + (shlex.split(args) if args else [])
-        cmd_str = ' '.join(cmd_list) # For logging
-        logger.info(f"Executing npm test: {cmd_str}") # Keep INFO for tool execution start
-        result = subprocess.run(cmd_list, capture_output=True, text=True, check=False, timeout=120) # check=False to capture output on failure
+        cmd_list = ["npm", "run", "test"] + (shlex.split(args) if args else []); cmd_str = ' '.join(cmd_list)
+        logger.info(f"Executing npm test: {cmd_str}")
+        result = subprocess.run(cmd_list, capture_output=True, text=True, check=False, timeout=120)
         output = f"Exit Code: {result.returncode}\nSTDOUT:\n{result.stdout.strip()}\nSTDERR:\n{result.stderr.strip()}"
-        if result.returncode == 0:
-            logger.debug(f"npm test completed successfully:\n{output}")
-            return f"OK: npm test finished.\n{output}"
-        else:
-            logger.error(f"npm test failed (Exit Code {result.returncode}):\n{output}")
-            return f"Error: npm test failed.\n{output}"
-    except FileNotFoundError:
-        logger.error("npm command not found. Is Node.js/npm installed and in PATH?")
-        return "Error: npm command not found."
-    except subprocess.TimeoutExpired:
-        logger.error("npm test command timed out.")
-        return "Error: npm test command timed out."
-    except Exception as e:
-        logger.error(f"Unexpected error during npm test: {e}", exc_info=logger.level <= logging.DEBUG)
-        return f"Error during npm test: {e}"
+        if result.returncode == 0: logger.debug(f"npm test completed successfully:\n{output}"); return f"OK: npm test finished.\n{output}"
+        else: logger.error(f"npm test failed (Exit Code {result.returncode}):\n{output}"); return f"Error: npm test failed.\n{output}"
+    except FileNotFoundError: logger.error("npm command not found."); return "Error: npm command not found."
+    except subprocess.TimeoutExpired: logger.error("npm test command timed out."); return "Error: npm test command timed out."
+    except Exception as e: logger.error(f"Unexpected error during npm test: {e}", exc_info=logger.level <= logging.DEBUG); return f"Error during npm test: {e}"
 
-@function_tool
-def run_pytest(args: str = "") -> str:
+def _run_pytest_logic(args: str = "") -> str:
     """Executes 'uv run pytest' with optional arguments."""
     try:
-        # Use shlex.split for safer argument handling
-        cmd_list = ["uv", "run", "pytest"] + (shlex.split(args) if args else [])
-        cmd_str = ' '.join(cmd_list) # For logging
-        logger.info(f"Executing pytest via uv: {cmd_str}") # Keep INFO for tool execution start
-        result = subprocess.run(cmd_list, capture_output=True, text=True, check=False, timeout=120) # check=False to capture output on failure
+        cmd_list = ["uv", "run", "pytest"] + (shlex.split(args) if args else []); cmd_str = ' '.join(cmd_list)
+        logger.info(f"Executing pytest via uv: {cmd_str}")
+        result = subprocess.run(cmd_list, capture_output=True, text=True, check=False, timeout=120)
         output = f"Exit Code: {result.returncode}\nSTDOUT:\n{result.stdout.strip()}\nSTDERR:\n{result.stderr.strip()}"
-        # Pytest often returns non-zero exit code on test failures, report this clearly
-        if result.returncode == 0:
-            logger.debug(f"pytest completed successfully:\n{output}")
-            return f"OK: pytest finished successfully.\n{output}"
-        else:
-            logger.warning(f"pytest finished with failures (Exit Code {result.returncode}):\n{output}")
-            # Still return "OK" from tool perspective, but indicate failure in the message
-            return f"OK: Pytest finished with failures (Exit Code {result.returncode}).\n{output}"
-    except FileNotFoundError:
-        logger.error("uv command not found. Is uv installed and in PATH?")
-        return "Error: uv command not found."
-    except subprocess.TimeoutExpired:
-        logger.error("pytest command timed out.")
-        return "Error: pytest command timed out."
-    except Exception as e:
-        logger.error(f"Unexpected error during pytest: {e}", exc_info=logger.level <= logging.DEBUG)
-        return f"Error during pytest: {e}"
+        if result.returncode == 0: logger.debug(f"pytest completed successfully:\n{output}"); return f"OK: pytest finished successfully.\n{output}"
+        else: logger.warning(f"pytest finished with failures (Exit Code {result.returncode}):\n{output}"); return f"OK: Pytest finished with failures (Exit Code {result.returncode}).\n{output}"
+    except FileNotFoundError: logger.error("uv command not found."); return "Error: uv command not found."
+    except subprocess.TimeoutExpired: logger.error("pytest command timed out."); return "Error: pytest command timed out."
+    except Exception as e: logger.error(f"Unexpected error during pytest: {e}", exc_info=logger.level <= logging.DEBUG); return f"Error during pytest: {e}"
+
+# --- Tool Definitions (Decorated - reverted to default naming) ---
+git_status = function_tool(_git_status_logic)
+git_diff = function_tool(_git_diff_logic)
+git_add = function_tool(_git_add_logic)
+git_commit = function_tool(_git_commit_logic)
+git_push = function_tool(_git_push_logic)
+run_npm_test = function_tool(_run_npm_test_logic)
+run_pytest = function_tool(_run_pytest_logic)
 
 # --- Agent Instructions ---
-# Define clear instructions for each agent's role and capabilities.
+# (Instructions remain the same)
 michael_instructions = """
 You are Michael Toasted, the resolute leader of the Burnt Noodles creative team.
 Your primary role is to understand the user's request, break it down into actionable steps,
@@ -244,50 +164,28 @@ Available Agent Tools: None (Report back to Michael for delegation).
 """
 
 # --- Blueprint Definition ---
-# Inherits from BlueprintBase, defines metadata, creates agents, and sets up delegation.
 class BurntNoodlesBlueprint(BlueprintBase):
-    """
-    Burnt Noodles Blueprint: A multi-agent team demonstrating Git operations and testing workflows.
-    - Michael Toasted: Coordinator, delegates tasks.
-    - Fiona Flame: Handles Git commands (status, diff, add, commit, push).
-    - Sam Ashes: Handles test execution (npm, pytest).
-    """
-    # Class variable for blueprint metadata, conforming to BlueprintBase structure.
     metadata: ClassVar[Dict[str, Any]] = {
         "name": "BurntNoodlesBlueprint",
         "title": "Burnt Noodles",
         "description": "A multi-agent team managing Git operations and code testing.",
-        "version": "1.1.0", # Incremented version
+        "version": "1.1.0",
         "author": "Open Swarm Team (Refactored)",
         "tags": ["git", "test", "multi-agent", "collaboration", "refactor"],
-        "required_mcp_servers": [], # No external MCP servers needed for core functionality
+        "required_mcp_servers": [],
     }
 
-    # Caches for OpenAI client and Model instances to avoid redundant creation.
     _openai_client_cache: Dict[str, AsyncOpenAI] = {}
     _model_instance_cache: Dict[str, Model] = {}
 
     def _get_model_instance(self, profile_name: str) -> Model:
-        """
-        Retrieves or creates an LLM Model instance based on the configuration profile.
-        Handles client instantiation and caching. Uses OpenAIChatCompletionsModel.
-        Args:
-            profile_name: The name of the LLM profile to use (e.g., 'default').
-        Returns:
-            An instance of the configured Model.
-        Raises:
-            ValueError: If configuration is missing or invalid.
-        """
-        # Check cache first
         if profile_name in self._model_instance_cache:
             logger.debug(f"Using cached Model instance for profile '{profile_name}'.")
             return self._model_instance_cache[profile_name]
 
         logger.debug(f"Creating new Model instance for profile '{profile_name}'.")
-        # Retrieve profile data using BlueprintBase helper method
         profile_data = getattr(self, "get_llm_profile", lambda prof: {"provider": "openai", "model": "gpt-mock"})(profile_name)
         if not profile_data:
-             # Critical error if the profile (or default fallback) isn't found
              logger.critical(f"Cannot create Model instance: LLM profile '{profile_name}' (or 'default') not found in configuration.")
              raise ValueError(f"Missing LLM profile configuration for '{profile_name}' or 'default'.")
 
@@ -297,21 +195,17 @@ class BurntNoodlesBlueprint(BlueprintBase):
              logger.critical(f"LLM profile '{profile_name}' is missing the required 'model' key.")
              raise ValueError(f"Missing 'model' key in LLM profile '{profile_name}'.")
 
-        # Ensure we only handle OpenAI for now
         if provider != "openai":
             logger.error(f"Unsupported LLM provider '{provider}' in profile '{profile_name}'. Only 'openai' is supported in this blueprint.")
             raise ValueError(f"Unsupported LLM provider: {provider}")
 
-        # Create or retrieve cached OpenAI client instance
         client_cache_key = f"{provider}_{profile_data.get('base_url')}"
         if client_cache_key not in self._openai_client_cache:
-             # Prepare arguments for AsyncOpenAI, filtering out None values
              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'} # Don't log API key
+             log_client_kwargs = {k:v for k,v in filtered_client_kwargs.items() if k != 'api_key'}
              logger.debug(f"Creating new AsyncOpenAI client for profile '{profile_name}' with config: {log_client_kwargs}")
              try:
-                 # Create and cache the client
                  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)
@@ -319,11 +213,9 @@ class BurntNoodlesBlueprint(BlueprintBase):
 
         openai_client_instance = self._openai_client_cache[client_cache_key]
 
-        # Instantiate the specific Model implementation (OpenAIChatCompletionsModel)
         logger.debug(f"Instantiating OpenAIChatCompletionsModel(model='{model_name}') with client instance for profile '{profile_name}'.")
         try:
             model_instance = OpenAIChatCompletionsModel(model=model_name, openai_client=openai_client_instance)
-            # Cache the model instance
             self._model_instance_cache[profile_name] = model_instance
             return model_instance
         except Exception as e:
@@ -331,82 +223,82 @@ class BurntNoodlesBlueprint(BlueprintBase):
              raise ValueError(f"Failed to initialize LLM provider for profile '{profile_name}': {e}") from e
 
     def create_starting_agent(self, mcp_servers: List[MCPServer]) -> Agent:
-        """
-        Creates the Burnt Noodles agent team: Michael (Coordinator), Fiona (Git), Sam (Testing).
-        Sets up tools and agent-as-tool delegation.
-        Args:
-            mcp_servers: List of started MCP server instances (not used by this BP).
-        Returns:
-            The starting agent instance (Michael Toasted).
-        """
         logger.debug("Creating Burnt Noodles agent team...")
         config = self._load_configuration() if getattr(self, "config", None) is None else self.config
-        # Clear caches at the start of agent creation for this run
         self._model_instance_cache = {}
         self._openai_client_cache = {}
-        
-        # Determine the LLM profile to use (e.g., from config or default)
+
         default_profile_name = config.get("llm_profile", "default")
         logger.debug(f"Using LLM profile '{default_profile_name}' for all Burnt Noodles agents.")
-        # Get the single Model instance to share among agents (or create if needed)
         default_model_instance = self._get_model_instance(default_profile_name)
 
-        # Instantiate the specialist agents first
-        # Fiona gets Git function tools
+        # --- Use the decorated tool variables ---
         fiona_flame = Agent(
-            name="Fiona_Flame", # Use names valid as tool names
+            name="Fiona_Flame",
             model=default_model_instance,
             instructions=fiona_instructions,
             tools=[git_status, git_diff, git_add, git_commit, git_push] # Agent tools added later
         )
-        # Sam gets Testing function tools
         sam_ashes = Agent(
-            name="Sam_Ashes", # Use names valid as tool names
+            name="Sam_Ashes",
             model=default_model_instance,
             instructions=sam_instructions,
             tools=[run_npm_test, run_pytest] # Agent tools added later
         )
-
-        # Instantiate the coordinator agent (Michael)
-        # Michael gets limited function tools and the specialist agents as tools
         michael_toasted = Agent(
              name="Michael_Toasted",
              model=default_model_instance,
              instructions=michael_instructions,
              tools=[
-                 # Michael's direct function tools (limited scope)
-                 git_status,
+                 git_status, # Michael's direct tools
                  git_diff,
-                 # Specialist agents exposed as tools for delegation
                  fiona_flame.as_tool(
-                     tool_name="Fiona_Flame", # Explicit tool name
+                     tool_name="Fiona_Flame",
                      tool_description="Delegate Git operations (add, commit, push) or complex status/diff queries to Fiona."
                  ),
                  sam_ashes.as_tool(
-                     tool_name="Sam_Ashes", # Explicit tool name
+                     tool_name="Sam_Ashes",
                      tool_description="Delegate testing tasks (npm test, pytest) to Sam."
                  ),
              ],
-             mcp_servers=mcp_servers # Pass along MCP servers if needed (though not used here)
+             mcp_servers=mcp_servers
         )
+        # --- End tool variable usage ---
 
-        # Add cross-delegation tools *after* all agents are instantiated
-        # Fiona can delegate testing to Sam
         fiona_flame.tools.append(
             sam_ashes.as_tool(tool_name="Sam_Ashes", tool_description="Delegate testing tasks (npm test, pytest) to Sam.")
         )
-        # Sam can delegate Git tasks back to Fiona (as per instructions, Sam should report to Michael,
-        # but having the tool technically available might be useful in complex future scenarios,
-        # rely on prompt engineering to prevent direct calls unless intended).
-        # sam_ashes.tools.append(
-        #     fiona_flame.as_tool(tool_name="Fiona_Flame", tool_description="Delegate Git operations back to Fiona if needed.")
-        # )
 
         logger.debug("Burnt Noodles agent team created successfully. Michael Toasted is the starting agent.")
-        # Return the coordinator agent as the entry point for the Runner
         return michael_toasted
 
+    async def run(self, messages: List[Dict[str, Any]], **kwargs) -> AsyncGenerator[Dict[str, Any], None]:
+        """
+        Main execution entry point for the Burnt Noodles blueprint.
+        Delegates to _run_non_interactive for CLI-like execution.
+        """
+        logger.info("BurntNoodlesBlueprint run method called.")
+        instruction = messages[-1].get("content", "") if messages else ""
+        async for chunk in self._run_non_interactive(instruction, **kwargs):
+            yield chunk
+        logger.info("BurntNoodlesBlueprint run method finished.")
+
+    async def _run_non_interactive(self, instruction: str, **kwargs) -> AsyncGenerator[Dict[str, Any], None]:
+        """Helper to run the agent flow based on an instruction."""
+        logger.info(f"Running Burnt Noodles non-interactively with instruction: '{instruction[:100]}...'")
+        mcp_servers = kwargs.get("mcp_servers", [])
+        starting_agent = self.create_starting_agent(mcp_servers=mcp_servers)
+        runner = Runner(agent=starting_agent)
+        try:
+            final_result = await runner.run(instruction)
+            logger.info(f"Non-interactive run finished. Final Output: {final_result.final_output}")
+            yield { "messages": [ {"role": "assistant", "content": final_result.final_output} ] }
+        except Exception as e:
+            logger.error(f"Error during non-interactive run: {e}", exc_info=True)
+            yield { "messages": [ {"role": "assistant", "content": f"An error occurred: {e}"} ] }
+
+
 # Standard Python entry point for direct script execution
 if __name__ == "__main__":
-    # Call the main class method from BlueprintBase to handle CLI parsing and execution.
     BurntNoodlesBlueprint.main()
+

swarm/blueprints/chatbot/blueprint_chatbot.py

@@ -3,11 +3,19 @@ import os
 import sys
 from typing import Dict, Any, List, ClassVar, Optional
 
+# Set logging to WARNING by default unless SWARM_DEBUG=1
+if not os.environ.get("SWARM_DEBUG"):
+    logging.basicConfig(level=logging.WARNING)
+else:
+    logging.basicConfig(level=logging.DEBUG)
+
 # Ensure src is in path for BlueprintBase import
 project_root = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..'))
 src_path = os.path.join(project_root, 'src')
 if src_path not in sys.path: sys.path.insert(0, src_path)
 
+from typing import Optional
+from pathlib import Path
 try:
     from agents import Agent, Tool, function_tool, Runner
     from agents.mcp import MCPServer
@@ -24,6 +32,13 @@ logger = logging.getLogger(__name__)
 
 # --- Define the Blueprint ---
 class ChatbotBlueprint(BlueprintBase):
+    def __init__(self, blueprint_id: str, config_path: Optional[Path] = None, **kwargs):
+        super().__init__(blueprint_id, config_path=config_path, **kwargs)
+
+        # Remove redundant client instantiation; rely on framework-level default client
+        # (No need to re-instantiate AsyncOpenAI or set_default_openai_client)
+        # All blueprints now use the default client set at framework init
+
     """A simple conversational chatbot agent."""
     metadata: ClassVar[Dict[str, Any]] = {
         "name": "ChatbotBlueprint",
@@ -42,19 +57,21 @@ class ChatbotBlueprint(BlueprintBase):
 
     # --- Model Instantiation Helper --- (Standard helper)
     def _get_model_instance(self, profile_name: str) -> Model:
-        """Retrieves or creates an LLM Model instance."""
-        # ... (Implementation is the same as previous refactors) ...
+        """Retrieves or creates an LLM Model instance, respecting LITELLM_MODEL/DEFAULT_LLM if set."""
         if profile_name in self._model_instance_cache:
             logger.debug(f"Using cached Model instance for profile '{profile_name}'.")
             return self._model_instance_cache[profile_name]
         logger.debug(f"Creating new Model instance for profile '{profile_name}'.")
         profile_data = self.get_llm_profile(profile_name)
-        if not profile_data: raise ValueError(f"Missing LLM profile '{profile_name}'.")
-        provider = profile_data.get("provider", "openai").lower()
-        model_name = profile_data.get("model")
+        # Patch: Respect LITELLM_MODEL/DEFAULT_LLM env vars
+        import os
+        model_name = os.getenv("LITELLM_MODEL") or os.getenv("DEFAULT_LLM") or profile_data.get("model")
+        profile_data["model"] = model_name
+        if profile_data.get("provider", "openai").lower() != "openai": raise ValueError(f"Unsupported provider: {profile_data.get('provider')}")
         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')}"
+
+        # REMOVE PATCH: env expansion is now handled globally in config loader
+        client_cache_key = f"{profile_data.get('provider', 'openai')}_{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}
@@ -93,6 +110,45 @@ class ChatbotBlueprint(BlueprintBase):
         logger.debug("Chatbot agent created.")
         return chatbot_agent
 
+    async def run(self, messages: List[Dict[str, Any]], **kwargs) -> Any:
+        """Main execution entry point for the Chatbot blueprint."""
+        logger.info("ChatbotBlueprint 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("ChatbotBlueprint run method finished.")
+
+    async def _run_non_interactive(self, instruction: str, **kwargs) -> Any:
+        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:
+            result = await Runner.run(agent, instruction)
+            yield {"messages": [{"role": "assistant", "content": getattr(result, 'final_output', str(result))}]}
+        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__":
-    ChatbotBlueprint.main()
+    import sys
+    import asyncio
+    # --- AUTO-PYTHONPATH PATCH FOR AGENTS ---
+    import os
+    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)
+    if '--instruction' in sys.argv:
+        instruction = sys.argv[sys.argv.index('--instruction') + 1]
+        blueprint = ChatbotBlueprint(blueprint_id="chatbot")
+        async def runner():
+            async for chunk in blueprint._run_non_interactive(instruction):
+                msg = chunk["messages"][0]["content"]
+                if not msg.startswith("An error occurred:"):
+                    print(msg)
+        asyncio.run(runner())
+    else:
+        print("Interactive mode not supported in this script.")

swarm/extensions/blueprint/runnable_blueprint.py

@@ -0,0 +1,42 @@
+import abc
+from typing import List, Dict, Any, AsyncGenerator
+
+# Assuming blueprint_base is in the same directory or accessible via installed package
+from .blueprint_base import BlueprintBase
+
+class RunnableBlueprint(BlueprintBase, abc.ABC):
+    """
+    Abstract base class for blueprints designed to be executed programmatically,
+    typically via an API endpoint like swarm-api.
+
+    Inherits common functionality from BlueprintBase and requires subclasses
+    to implement the `run` method as the standard entry point for execution.
+    """
+
+    @abc.abstractmethod
+    async def run(self, messages: List[Dict[str, Any]], **kwargs) -> AsyncGenerator[Dict[str, Any], None]:
+        """
+        Abstract method defining the standard entry point for running the blueprint
+        programmatically.
+
+        Args:
+            messages: A list of message dictionaries, typically following the
+                      OpenAI chat completions format. The last message is usually
+                      the user's input or instruction.
+            **kwargs: Additional keyword arguments that might be passed by the
+                      runner (e.g., mcp_servers, configuration overrides).
+
+        Yields:
+            Dictionaries representing chunks of the response, often containing
+            a 'messages' key with a list of message objects. The exact format
+            may depend on the runner's expectations (e.g., SSE for streaming).
+
+        Raises:
+            NotImplementedError: If the subclass does not implement this method.
+        """
+        raise NotImplementedError("Subclasses of RunnableBlueprint must implement the 'run' method.")
+        # This yield is technically unreachable but satisfies static analysis
+        # expecting a generator function body.
+        if False:
+             yield {}
+