open-swarm 0.1.1743372974__py3-none-any.whl → 0.1.1743449197__py3-none-any.whl

{open_swarm-0.1.1743372974.dist-info → open_swarm-0.1.1743449197.dist-info}/METADATA

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

@@ -3,17 +3,18 @@ swarm/apps.py,sha256=up4C3m2JeyXeUcH-wYeReCuiOBVJ6404w9OfaRChLwM,2568
 swarm/auth.py,sha256=8JIk1VbBvFFwOijEJAsrx6si802ZSMGnErXvmo0izUg,5935
 swarm/consumers.py,sha256=wESLamkhbi4SEZt9k3yx6eU9ufOIZMCAL-OAXjJBGXE,5056
 swarm/messages.py,sha256=CwADrjlj-uVmm-so1xIZvN1UkEWdzSn_hu7slfhuS8w,6549
+swarm/middleware.py,sha256=lPlHbFg9Rm9lUuvg026d4zTDjRMc8bQi0JegpGdqIZQ,3198
 swarm/models.py,sha256=Ix0WEYYqza2lbOEBNesikRCs3XGUPWmqQyMWzZYUaxM,1494
 swarm/permissions.py,sha256=iM86fSL1TtgqJzgDkS3Dl82X6Xk7VDHWwdBDfs5RKWc,1671
 swarm/serializers.py,sha256=4g3G2FdWpSIuLLC_SBKoNITw1b0G83Bxo7YHc-kjsro,4550
-swarm/settings.py,sha256=rGPcnLSf6WetpeovBb6AhDzWi2GwaFbsQ8UZjRVTMtI,6334
+swarm/settings.py,sha256=wrQoWfNylY_54z5c54x0TLe2Q9KEqvawNXjqCVhWuyI,6616
 swarm/tool_executor.py,sha256=KHM2mTGgbbTgWNN3fbV5c4MDY238OTLwaaqtkczFHFQ,12385
 swarm/urls.py,sha256=9eRQWsB-Vs3Nmes4mtlZtk_Rvuixf4Y9uwrX9dVQ9Is,3292
 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=LwKVYTRRg6ceNpvbuzM-bl7NukBGNu3bOU9Q3h6WjOU,22834
+swarm/blueprints/burnt_noodles/blueprint_burnt_noodles.py,sha256=vopDlBjVUNeSq6WItdkmtWJfObgbtL6wNAy2njsskkY,19607
 swarm/blueprints/chatbot/blueprint_chatbot.py,sha256=D31OgSoxllhzn8f7cdVYflqzadN2SZ61rabPuK6EqQ8,4728
 swarm/blueprints/chatbot/templates/chatbot/chatbot.html,sha256=REFnqNg0EHsXxAUfaCJe1YgOKiV_umBXuC6y8veF5CU,1568
 swarm/blueprints/digitalbutlers/blueprint_digitalbutlers.py,sha256=JK_rmZgPMw4PdQFrMverrwgcjH0NRkuqkchYOJwXYuM,9809
@@ -62,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
@@ -253,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.1743372974.dist-info/METADATA,sha256=blPlP9G_zGz6Vi-7nxiIpWiegGOvObE1FCYtDJJf3aw,13678
-open_swarm-0.1.1743372974.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-open_swarm-0.1.1743372974.dist-info/entry_points.txt,sha256=LudR3dBqGnglrE1n2zAeWo38Ck0m57sKPW36KfK-pzo,71
-open_swarm-0.1.1743372974.dist-info/licenses/LICENSE,sha256=BU9bwRlnOt_JDIb6OT55Q4leLZx9RArDLTFnlDIrBEI,1062
-open_swarm-0.1.1743372974.dist-info/RECORD,,
+open_swarm-0.1.1743449197.dist-info/METADATA,sha256=dtlfI53Sbe7oMT0WtK01-I0kyIpDCz8OXr8KWeU1_dc,13678
+open_swarm-0.1.1743449197.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+open_swarm-0.1.1743449197.dist-info/entry_points.txt,sha256=z1UIVRRhri-V-hWxFkDEYu0SZPUIsVO4KpDaodgcFzU,125
+open_swarm-0.1.1743449197.dist-info/licenses/LICENSE,sha256=BU9bwRlnOt_JDIb6OT55Q4leLZx9RArDLTFnlDIrBEI,1062
+open_swarm-0.1.1743449197.dist-info/RECORD,,

{open_swarm-0.1.1743372974.dist-info → open_swarm-0.1.1743449197.dist-info}/entry_points.txt

@@ -1,2 +1,3 @@
 [console_scripts]
+swarm-api = swarm.extensions.launchers.swarm_api:main
 swarm-cli = swarm.extensions.launchers.swarm_cli:app

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,192 +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}"
+    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}"
 
-@function_tool
-def git_diff() -> str:
+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}"
+             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}"
 
-    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,
@@ -245,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 = self.get_llm_profile(profile_name)
+        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'.")
 
@@ -298,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)
@@ -320,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:
@@ -332,81 +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...")
-        # Clear caches at the start of agent creation for this run
+        config = self._load_configuration() if getattr(self, "config", None) is None else self.config
         self._model_instance_cache = {}
         self._openai_client_cache = {}
 
-        # Determine the LLM profile to use (e.g., from config or default)
-        default_profile_name = self.config.get("llm_profile", "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/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 {}
+

swarm/middleware.py

@@ -0,0 +1,65 @@
+# src/swarm/middleware.py
+import logging
+import asyncio # Import asyncio
+from asgiref.sync import sync_to_async
+from django.utils.functional import SimpleLazyObject
+from django.utils.decorators import sync_and_async_middleware
+from django.contrib.auth.middleware import AuthenticationMiddleware
+
+logger = logging.getLogger(__name__)
+
+# Mark the middleware as compatible with both sync and async views
+@sync_and_async_middleware
+def AsyncAuthMiddleware(get_response):
+    """
+    Ensures request.user is loaded asynchronously before reaching async views,
+    preventing SynchronousOnlyOperation errors during authentication checks
+    that might involve database access (like session loading).
+
+    This should be placed *after* Django's built-in AuthenticationMiddleware.
+    """
+
+    # One-time configuration and initialization.
+    # (Not needed for this simple middleware)
+
+    async def middleware(request):
+        # Code to be executed for each request before
+        # the view (and later middleware) are called.
+
+        # Check if request.user is a SimpleLazyObject and hasn't been evaluated yet.
+        # Django's AuthenticationMiddleware sets request.user to a SimpleLazyObject
+        # wrapping the get_user function. Accessing request.user triggers evaluation.
+        if isinstance(request.user, SimpleLazyObject):
+            # Use sync_to_async to safely evaluate the lazy object (which calls
+            # the synchronous get_user function) in an async context.
+            # We don't need the result here, just to trigger the load.
+            try:
+                logger.debug("[AsyncAuthMiddleware] Attempting async user load...")
+                _ = await sync_to_async(request.user._setup)() # Access internal _setup to force load
+                is_auth = await sync_to_async(lambda: getattr(request.user, 'is_authenticated', False))()
+                logger.debug(f"[AsyncAuthMiddleware] User loaded via SimpleLazyObject: {request.user}, Authenticated: {is_auth}")
+            except Exception as e:
+                # Log potential errors during user loading but don't block the request
+                logger.error(f"[AsyncAuthMiddleware] Error during async user load: {e}", exc_info=True)
+                # You might want to handle specific auth errors differently
+        else:
+            # If it's not a SimpleLazyObject, it might be already loaded or AnonymousUser
+            is_auth = getattr(request.user, 'is_authenticated', False)
+            logger.debug(f"[AsyncAuthMiddleware] User already loaded or not lazy: {request.user}, Authenticated: {is_auth}")
+
+
+        response = await get_response(request)
+
+        # Code to be executed for each request/response after
+        # the view is called.
+
+        return response
+
+    # Return the correct function based on whether get_response is async or sync
+    if asyncio.iscoroutinefunction(get_response):
+        return middleware
+    else:
+        # If the next middleware/view is sync, we don't need our async wrapper
+        # However, the decorator handles this, so we just return the async version.
+        # For clarity, the decorator makes this middleware compatible either way.
+        return middleware

swarm/settings.py

@@ -28,6 +28,8 @@ ENABLE_API_AUTH = bool(_raw_api_token)
 SWARM_API_KEY = _raw_api_token # Assign the loaded token (or None)
 
 if ENABLE_API_AUTH:
+    # Add assertion to satisfy type checkers within this block
+    assert SWARM_API_KEY is not None, "SWARM_API_KEY cannot be None when ENABLE_API_AUTH is True"
     print(f"[Settings] SWARM_API_KEY loaded: {SWARM_API_KEY[:4]}...{SWARM_API_KEY[-4:]}")
     print("[Settings] ENABLE_API_AUTH is True.")
 else:
@@ -58,6 +60,8 @@ MIDDLEWARE = [
     'django.middleware.common.CommonMiddleware',
     'django.middleware.csrf.CsrfViewMiddleware',
     'django.contrib.auth.middleware.AuthenticationMiddleware',
+    # Add custom middleware to handle async user loading after standard auth
+    'swarm.middleware.AsyncAuthMiddleware',
     'django.contrib.messages.middleware.MessageMiddleware',
     'django.middleware.clickjacking.XFrameOptionsMiddleware',
 ]