open-swarm 0.1.1743070217__py3-none-any.whl → 0.1.1743364176__py3-none-any.whl

swarm/extensions/blueprint/blueprint_base.py

@@ -1,562 +1,160 @@
-"""
-Swarm Blueprint Base Module (Sync Interactive Mode)
-"""
-
-import asyncio
-import json
 import logging
-from src.swarm.utils.message_sequence import repair_message_payload, validate_message_sequence
-from src.swarm.utils.context_utils import truncate_message_history, get_token_count
 import os
-import uuid
-import sys
+import inspect
+from typing import Dict, List, Any, AsyncGenerator, Optional, Type
 from abc import ABC, abstractmethod
-from typing import Optional, Dict, Any, List
-
+from jinja2 import Environment, FileSystemLoader, select_autoescape
 from pathlib import Path
-from swarm.core import Swarm
-from swarm.extensions.config.config_loader import load_server_config
-from swarm.settings import DEBUG
-from swarm.utils.redact import redact_sensitive_data
-from swarm.utils.context_utils import get_token_count, truncate_message_history
-from swarm.extensions.blueprint.agent_utils import (
-    get_agent_name,
-    discover_tools_for_agent,
-    discover_resources_for_agent,
-    initialize_agents
-)
-from swarm.extensions.blueprint.django_utils import register_django_components
-from swarm.extensions.blueprint.spinner import Spinner
-from swarm.extensions.blueprint.output_utils import pretty_print_response
-from dotenv import load_dotenv
-import argparse
-from swarm.types import Agent, Response
-
-logger = logging.getLogger(__name__)
-
-class BlueprintBase(ABC):
-    """Base class for Swarm blueprints with sync interactive mode and Django integration."""
-
-    def __init__(
-        self,
-        config: dict,
-        auto_complete_task: bool = False,
-        update_user_goal: bool = False,
-        update_user_goal_frequency: int = 5,
-        skip_django_registration: bool = False,
-        record_chat: bool = False,
-        log_file_path: Optional[str] = None,
-        debug: bool = False,
-        use_markdown: bool = False,
-        **kwargs
-    ):
-        self.auto_complete_task = auto_complete_task
-        self.update_user_goal = update_user_goal
-        self.update_user_goal_frequency = max(1, update_user_goal_frequency)
-        self.last_goal_update_count = 0
-        self.record_chat = record_chat
-        self.conversation_id = str(uuid.uuid4()) if record_chat else None
-        self.log_file_path = log_file_path
-        self.debug = debug or DEBUG
-        self.use_markdown = use_markdown
-        self._urls_registered = False
-
-        if self.use_markdown:
-            logger.debug("Markdown rendering enabled (if rich is available).")
-        logger.debug(f"Initializing {self.__class__.__name__} with config: {redact_sensitive_data(config)}")
-        if not hasattr(self, 'metadata') or not isinstance(self.metadata, dict):
-            raise AssertionError(f"{self.__class__.__name__} must define a 'metadata' property returning a dictionary.")
+import copy
+# *** Import Django settings ***
+from django.conf import settings
 
-        self.truncation_mode = os.getenv("SWARM_TRUNCATION_MODE", "pairs").lower()
-        self.max_context_tokens = max(1, self.metadata.get("max_context_tokens", 8000))
-        self.max_context_messages = max(1, self.metadata.get("max_context_messages", 50))
-        logger.debug(f"Truncation settings: mode={self.truncation_mode}, max_tokens={self.max_context_tokens}, max_messages={self.max_context_messages}")
+# *** REMOVE SwarmConfig import from apps.py ***
+# from swarm.apps import SwarmConfig
 
-        load_dotenv()
-        logger.debug("Loaded environment variables from .env.")
+# Import helpers from config_loader if needed directly
+# from swarm.extensions.config.config_loader import find_config_file, DEFAULT_CONFIG_FILENAME
 
-        self.config = config
-        self.skip_django_registration = skip_django_registration or not os.environ.get("DJANGO_SETTINGS_MODULE")
-        self.swarm = kwargs.get('swarm_instance') or Swarm(config=self.config, debug=self.debug)
-        logger.debug("Swarm instance initialized.")
+# *** LLMRegistry doesn't exist yet - Comment out import ***
+# from swarm.llm.llm_registry import LLMRegistry # Example path - CHANGE ME!
 
-        self.context_variables: Dict[str, Any] = {"user_goal": ""}
-        self.starting_agent = None
-        self._discovered_tools: Dict[str, List[Any]] = {}
-        self._discovered_resources: Dict[str, List[Any]] = {}
-        self.spinner = Spinner(interactive=not kwargs.get('non_interactive', False))
-
-        required_env_vars = set(self.metadata.get('env_vars', []))
-        missing_vars = [var for var in required_env_vars if not os.getenv(var)]
-        if missing_vars:
-            logger.warning(f"Missing environment variables for {self.metadata.get('title', self.__class__.__name__)}: {', '.join(missing_vars)}")
-
-        self.required_mcp_servers = self.metadata.get('required_mcp_servers', [])
-        logger.debug(f"Required MCP servers: {self.required_mcp_servers}")
-
-        if self._is_create_agents_overridden():
-            initialize_agents(self)
-        register_django_components(self)
-
-    def _is_create_agents_overridden(self) -> bool:
-        """Check if the 'create_agents' method is overridden in the subclass."""
-        return self.__class__.create_agents is not BlueprintBase.create_agents
+logger = logging.getLogger(__name__)
 
-    def truncate_message_history(self, messages: List[Dict[str, Any]], model: str) -> List[Dict[str, Any]]:
-        """Truncate message history using the centralized utility."""
-        return truncate_message_history(messages, model, self.max_context_tokens, self.max_context_messages)
+class BlueprintBase(ABC):
+    """
+    Abstract base class for all blueprints.
+    Ensures common interface and configuration handling.
+    """
+    metadata: Dict[str, Any] = {}
 
-    @property
     @abstractmethod
-    def metadata(self) -> Dict[str, Any]:
-        """Abstract property for blueprint metadata."""
-        raise NotImplementedError
-
-    def create_agents(self) -> Dict[str, Agent]:
-        """Default agent creation method."""
-        return {}
-
-    def set_starting_agent(self, agent: Agent) -> None:
-        """Set the starting agent and trigger initial asset discovery."""
-        agent_name = get_agent_name(agent)
-        logger.debug(f"Setting starting agent to: {agent_name}")
-        self.starting_agent = agent
-        self.context_variables["active_agent_name"] = agent_name
-
-        try:
-            loop = asyncio.get_event_loop()
-            is_running = loop.is_running()
-        except RuntimeError:
-            loop = None
-            is_running = False
-
-        # Corrected calls: Pass only agent and config
-        if loop and is_running:
-            logger.debug(f"Scheduling async asset discovery for starting agent {agent_name}.")
-            asyncio.ensure_future(discover_tools_for_agent(agent, self.swarm.config))
-            asyncio.ensure_future(discover_resources_for_agent(agent, self.swarm.config))
-        else:
-            logger.debug(f"Running sync asset discovery for starting agent {agent_name}.")
-            try:
-                asyncio.run(discover_tools_for_agent(agent, self.swarm.config))
-                asyncio.run(discover_resources_for_agent(agent, self.swarm.config))
-            except RuntimeError as e:
-                 if "cannot be called from a running event loop" in str(e): logger.error("Nested asyncio.run detected during sync discovery.")
-                 else: raise e
-
-    async def determine_active_agent(self) -> Optional[Agent]:
-        """Determine the currently active agent."""
-        active_agent_name = self.context_variables.get("active_agent_name")
-        agent_to_use = None
-
-        if active_agent_name and active_agent_name in self.swarm.agents:
-             agent_to_use = self.swarm.agents[active_agent_name]
-             logger.debug(f"Determined active agent from context: {active_agent_name}")
-        elif self.starting_agent:
-             agent_to_use = self.starting_agent
-             active_agent_name = get_agent_name(agent_to_use)
-             if self.context_variables.get("active_agent_name") != active_agent_name:
-                  self.context_variables["active_agent_name"] = active_agent_name
-                  logger.debug(f"Falling back to starting agent: {active_agent_name} and updating context.")
-             else:
-                  logger.debug(f"Using starting agent: {active_agent_name}")
-        else:
-             logger.error("Cannot determine active agent: No agent name in context and no starting agent set.")
-             return None
-
-        agent_name_cache_key = get_agent_name(agent_to_use)
-        # Corrected calls: Pass only agent and config
-        if agent_name_cache_key not in self._discovered_tools:
-             logger.debug(f"Cache miss for tools of agent {agent_name_cache_key}. Discovering...")
-             discovered_tools = await discover_tools_for_agent(agent_to_use, self.swarm.config)
-             self._discovered_tools[agent_name_cache_key] = discovered_tools
-
-        if agent_name_cache_key not in self._discovered_resources:
-             logger.debug(f"Cache miss for resources of agent {agent_name_cache_key}. Discovering...")
-             discovered_resources = await discover_resources_for_agent(agent_to_use, self.swarm.config)
-             self._discovered_resources[agent_name_cache_key] = discovered_resources
-
-        return agent_to_use
-
-    # --- Core Execution Logic ---
-    def run_with_context(self, messages: List[Dict[str, str]], context_variables: dict) -> dict:
-        """Synchronous wrapper for the async execution logic."""
-        return asyncio.run(self.run_with_context_async(messages, context_variables))
-
-    async def run_with_context_async(self, messages: List[Dict[str, str]], context_variables: dict) -> dict:
-        """Asynchronously run the blueprint's logic."""
-        self.context_variables.update(context_variables)
-        logger.debug(f"Context variables updated: {self.context_variables}")
-
-        active_agent = await self.determine_active_agent()
-        if not active_agent:
-            logger.error("No active agent could be determined. Cannot proceed.")
-            return {"response": Response(messages=[{"role": "assistant", "content": "Error: No active agent available."}], agent=None, context_variables=self.context_variables), "context_variables": self.context_variables}
-
-        model = getattr(active_agent, 'model', None) or self.swarm.current_llm_config.get("model", "default")
-        logger.debug(f"Using model: {model} for agent {get_agent_name(active_agent)}")
-
-        truncated_messages = self.truncate_message_history(messages, model)
-        validated_messages = validate_message_sequence(truncated_messages)
-        repaired_messages = repair_message_payload(validated_messages, debug=self.debug)
-
-        if not self.swarm.agents:
-            logger.warning("No agents registered; returning default response.")
-            return {"response": Response(messages=[{"role": "assistant", "content": "No agents available in Swarm."}], agent=None, context_variables=self.context_variables), "context_variables": self.context_variables}
-
-        logger.debug(f"Running Swarm core with agent: {get_agent_name(active_agent)}")
-        self.spinner.start(f"Generating response from {get_agent_name(active_agent)}")
-        response_obj = None
-        try:
-            response_obj = await self.swarm.run(
-                 agent=active_agent, messages=repaired_messages, context_variables=self.context_variables,
-                 stream=False, debug=self.debug,
-            )
-        except Exception as e:
-            logger.error(f"Swarm run failed: {e}", exc_info=True)
-            response_obj = Response(messages=[{"role": "assistant", "content": f"An error occurred: {str(e)}"}], agent=active_agent, context_variables=self.context_variables)
-        finally:
-            self.spinner.stop()
-
-        final_agent = active_agent
-        updated_context = self.context_variables.copy()
-
-        if response_obj:
-             if hasattr(response_obj, 'agent') and response_obj.agent and get_agent_name(response_obj.agent) != get_agent_name(active_agent):
-                 final_agent = response_obj.agent
-                 new_agent_name = get_agent_name(final_agent)
-                 updated_context["active_agent_name"] = new_agent_name
-                 logger.debug(f"Agent handoff occurred. New active agent: {new_agent_name}")
-                 # Corrected calls: Pass only agent and config
-                 asyncio.ensure_future(discover_tools_for_agent(final_agent, self.swarm.config))
-                 asyncio.ensure_future(discover_resources_for_agent(final_agent, self.swarm.config))
-             if hasattr(response_obj, 'context_variables'):
-                  updated_context.update(response_obj.context_variables)
-        else:
-            logger.error("Swarm run returned None or invalid response structure.")
-            response_obj = Response(messages=[{"role": "assistant", "content": "Error processing the request."}], agent=active_agent, context_variables=updated_context)
-
-        return {"response": response_obj, "context_variables": updated_context}
-
-    def set_active_agent(self, agent_name: str) -> None:
-        """Explicitly set the active agent by name and trigger asset discovery."""
-        if agent_name in self.swarm.agents:
-            self.context_variables["active_agent_name"] = agent_name
-            agent = self.swarm.agents[agent_name]
-            logger.debug(f"Explicitly setting active agent to: {agent_name}")
-            # Corrected calls: Pass only agent and config
-            if agent_name not in self._discovered_tools:
-                 logger.debug(f"Discovering tools for explicitly set agent {agent_name}.")
-                 try: asyncio.run(discover_tools_for_agent(agent, self.swarm.config))
-                 except RuntimeError as e:
-                      if "cannot be called from a running event loop" in str(e): logger.error("Cannot run sync discovery from within an async context (set_active_agent).")
-                      else: raise e
-            if agent_name not in self._discovered_resources:
-                 logger.debug(f"Discovering resources for explicitly set agent {agent_name}.")
-                 try: asyncio.run(discover_resources_for_agent(agent, self.swarm.config))
-                 except RuntimeError as e:
-                       if "cannot be called from a running event loop" in str(e): logger.error("Cannot run sync discovery from within an async context (set_active_agent).")
-                       else: raise e
-        else:
-            logger.error(f"Attempted to set active agent to '{agent_name}', but agent not found.")
-
-    # --- Task Completion & Goal Update Logic ---
-    async def _is_task_done_async(self, user_goal: str, conversation_summary: str, last_assistant_message: str) -> bool:
-        """Check if the task defined by user_goal is complete using an LLM call."""
-        if not user_goal:
-             logger.warning("Cannot check task completion: user_goal is empty.")
-             return False
-
-        system_prompt = os.getenv("TASK_DONE_PROMPT", "You are a completion checker. Respond with ONLY 'YES' or 'NO'.")
-        user_prompt = os.getenv(
-            "TASK_DONE_USER_PROMPT",
-            "User's goal: {user_goal}\nConversation summary: {conversation_summary}\nLast assistant message: {last_assistant_message}\nIs the task fully complete? Answer only YES or NO."
-        ).format(user_goal=user_goal, conversation_summary=conversation_summary, last_assistant_message=last_assistant_message)
-
-        check_prompt = [{"role": "system", "content": system_prompt}, {"role": "user", "content": user_prompt}]
-        client = self.swarm.client
-        model_to_use = self.swarm.current_llm_config.get("model", self.swarm.model)
-
-        try:
-            response = await client.chat.completions.create(
-                model=model_to_use, messages=check_prompt, max_tokens=5, temperature=0
-            )
-            if response.choices:
-                 result_content = response.choices[0].message.content.strip().upper()
-                 is_done = result_content.startswith("YES")
-                 logger.debug(f"Task completion check (Goal: '{user_goal}', LLM Raw: '{result_content}'): {is_done}")
-                 return is_done
-            else:
-                 logger.warning("LLM response for task completion check had no choices.")
-                 return False
-        except Exception as e:
-            logger.error(f"Task completion check LLM call failed: {e}", exc_info=True)
-            return False
-
-    async def _update_user_goal_async(self, messages: List[Dict[str, str]]) -> None:
-        """Update the 'user_goal' in context_variables based on conversation history using an LLM call."""
-        if not messages:
-            logger.debug("Cannot update goal: No messages provided.")
-            return
-
-        system_prompt = os.getenv(
-            "UPDATE_GOAL_PROMPT",
-            "You are an assistant that summarizes the user's primary objective from the conversation. Provide a concise, one-sentence summary."
-        )
-        conversation_text = "\n".join(f"{m['role']}: {m.get('content', '')}" for m in messages if m.get('content') or m.get('tool_calls'))
-        if not conversation_text:
-             logger.debug("Cannot update goal: No content in messages.")
-             return
-
-        user_prompt = os.getenv(
-            "UPDATE_GOAL_USER_PROMPT",
-            "Summarize the user's main goal based on this conversation:\n{conversation}"
-        ).format(conversation=conversation_text)
-
-        prompt = [{"role": "system", "content": system_prompt}, {"role": "user", "content": user_prompt}]
-        client = self.swarm.client
-        model_to_use = self.swarm.current_llm_config.get("model", self.swarm.model)
+    async def run(self, messages: List[Dict[str, str]]) -> AsyncGenerator[Dict[str, Any], None]:
+        """
+        Asynchronously runs the blueprint logic with the given messages.
+        Must be implemented by subclasses.
+        """
+        if False: yield {}
+        pass
 
+    def __init__(
+        self,
+        # config_override: Optional[Dict] = None, # Override logic needs rethink
+        params: Optional[Dict] = None,
+    ):
+        logger.debug(f"BlueprintBase.__init__ starting for {self.__class__.__name__}")
+        self.params = params if params else {}
+        # self._config_override = config_override # Store override for use in _configure
+        # self._resolved_config_path = None # Initialize path tracker
+
+        # Configuration loading needs rethink - access via settings for now
+        self._configure() # This sets self.config attributes from settings
+
+        # Now setup others that might depend on config
+        self._setup_llm() # Uses self.config attributes
+        self._setup_jinja() # Uses class path
+
+        # Logging Adjustment
+        # Check config *after* it has been loaded by _configure
+        # Use self.is_debug which should be set in _configure
+        if hasattr(self, 'is_debug') and self.is_debug:
+             log_level_int = logging.DEBUG
+             if logging.root.level > log_level_int:
+                logger.info(f"Root logger level is {logging.getLevelName(logging.root.level)}. Lowering to DEBUG due to config.")
+                logging.root.setLevel(log_level_int)
+
+        # Ensure llm_profile_name is set by _setup_llm before logging it
+        # Add check if llm_profile_name exists before logging
+        profile_name_to_log = getattr(self, 'llm_profile_name', 'N/A')
+        logger.info(f"Initialized blueprint '{self.metadata.get('name', self.__class__.__name__)}' with profile '{profile_name_to_log}'")
+
+    def _configure(self):
+        """Placeholder: Sets config attributes based on django.conf.settings."""
+        logger.debug("BlueprintBase._configure accessing django.conf.settings")
+        # *** Access settings directly (temporary) ***
+        # This assumes swarm_config.json content is NOT yet loaded into settings
+        # We'll rely on defaults or potentially fail in _setup_llm
+        self.is_debug = getattr(settings, 'DEBUG', False)
+        # Store blueprint-specific parts for convenience - these won't exist in settings yet!
+        self.blueprint_config = {} # Placeholder
+        self.blueprint_defaults = {} # Placeholder
+        logger.warning("_configure is using placeholders. Swarm config file content is not loaded here.")
+
+
+    def _setup_llm(self):
+        """Sets up the LLM provider based on configuration stored in self.config."""
+        # *** Access settings directly (temporary) ***
+        # Get default profile name from settings if defined, else 'default'
+        default_profile = getattr(settings, 'DEFAULT_LLM_PROFILE', 'default')
+        self.llm_profile_name = self.blueprint_config.get('llm_profile', default_profile) # Use placeholder blueprint_config
+        logger.debug(f"Getting LLM profile details for '{self.llm_profile_name}'.")
+
+        # *** This part will likely fail or use defaults as swarm_config isn't in settings ***
+        # Attempt to get profiles from settings if they were somehow loaded there
+        all_llm_profiles = getattr(settings, 'LLM_PROFILES', {})
+        profile_data = all_llm_profiles.get(self.llm_profile_name)
+
+        if profile_data is None:
+            logger.warning(f"LLM profile '{self.llm_profile_name}' not found in django settings. LLM will not be available.")
+            self.llm_profile = {} # Set empty profile
+            self.llm = None # Set LLM to None
+            return # Exit setup early
+
+        logger.debug(f"Using LLM profile '{self.llm_profile_name}' from settings.")
+        self.llm_profile = profile_data
+        # *** LLMRegistry doesn't exist yet - Comment out usage and set placeholder ***
+        # self.llm = LLMRegistry.get_llm(self.llm_profile)
+        self.llm = None # Placeholder until registry is implemented
+        logger.warning("LLMRegistry not implemented. self.llm set to None.")
+
+
+    @staticmethod
+    def _substitute_env_vars(data: Any) -> Any:
+        """Recursively substitutes environment variables in strings."""
+        if isinstance(data, dict):
+            return {k: BlueprintBase._substitute_env_vars(v) for k, v in data.items()}
+        if isinstance(data, list):
+            return [BlueprintBase._substitute_env_vars(item) for item in data]
+        if isinstance(data, str):
+            return os.path.expandvars(data)
+        return data
+
+    def _setup_jinja(self):
+        """Sets up Jinja2 environment."""
         try:
-            response = await client.chat.completions.create(
-                model=model_to_use, messages=prompt, max_tokens=60, temperature=0.3
-            )
-            if response.choices:
-                 new_goal = response.choices[0].message.content.strip()
-                 if new_goal:
-                      self.context_variables["user_goal"] = new_goal
-                      logger.debug(f"Updated user goal via LLM: {new_goal}")
-                 else:
-                      logger.warning("LLM goal update returned empty response.")
+            blueprint_file_path = inspect.getfile(self.__class__)
+            blueprint_dir = os.path.dirname(blueprint_file_path)
+            template_dir = os.path.join(blueprint_dir, 'templates')
+            if os.path.isdir(template_dir):
+                 logger.debug(f"Setting up Jinja env with loader at: {template_dir}")
+                 self.jinja_env = Environment(
+                     loader=FileSystemLoader(template_dir),
+                     autoescape=select_autoescape(['html', 'xml'])
+                 )
             else:
-                 logger.warning("LLM response for goal update had no choices.")
+                 logger.debug(f"No 'templates' directory found for blueprint at {template_dir}. Jinja env not created.")
+                 self.jinja_env = None
         except Exception as e:
-            logger.error(f"User goal update LLM call failed: {e}", exc_info=True)
-
-    def task_completed(self, outcome: str) -> None:
-        """Placeholder method potentially used by agents to signal task completion."""
-        print(f"Task Outcome: {outcome}")
-        print("continue")
-
-    @property
-    def prompt(self) -> str:
-        """Return the custom prompt string, potentially from the active agent."""
-        active_agent = self.swarm.agents.get(self.context_variables.get("active_agent_name"))
-        return getattr(active_agent, 'prompt', getattr(self, "custom_user_prompt", "User: "))
-
-    # --- Interactive & Non-Interactive Modes ---
-    def interactive_mode(self, stream: bool = False) -> None:
-        """Run the blueprint in interactive command-line mode."""
-        from .interactive_mode import run_interactive_mode
-        run_interactive_mode(self, stream)
-
-    def non_interactive_mode(self, instruction: str, stream: bool = False) -> None:
-        """Run the blueprint non-interactively with a single instruction."""
-        logger.debug(f"Starting non-interactive mode with instruction: {instruction}, stream={stream}")
-        try:
-             asyncio.run(self.non_interactive_mode_async(instruction, stream=stream))
-        except RuntimeError as e:
-             if "cannot be called from a running event loop" in str(e):
-                  logger.error("Cannot start non_interactive_mode with asyncio.run from an existing event loop.")
-             else: raise e
-
-    async def non_interactive_mode_async(self, instruction: str, stream: bool = False) -> None:
-        """Asynchronously run the blueprint non-interactively."""
-        logger.debug(f"Starting async non-interactive mode with instruction: {instruction}, stream={stream}")
-        if not self.swarm:
-            logger.error("Swarm instance not initialized.")
-            print("Error: Swarm framework not ready.")
-            return
-
-        print(f"--- {self.metadata.get('title', 'Blueprint')} Non-Interactive Mode ---")
-        instructions = [line.strip() for line in instruction.splitlines() if line.strip()]
-        if not instructions:
-             print("No valid instruction provided.")
-             return
-        messages = [{"role": "user", "content": line} for line in instructions]
-
-        if not self.starting_agent:
-             if self.swarm.agents:
-                 first_agent_name = next(iter(self.swarm.agents.keys()))
-                 logger.warning(f"No starting agent explicitly set. Defaulting to first agent: {first_agent_name}")
-                 self.set_starting_agent(self.swarm.agents[first_agent_name])
-             else:
-                 logger.error("No starting agent set and no agents defined.")
-                 print("Error: No agent available to handle the instruction.")
-                 return
-
-        self.context_variables["user_goal"] = instruction
-        self.context_variables["active_agent_name"] = get_agent_name(self.starting_agent)
-
-        if stream:
-            logger.debug("Running non-interactive in streaming mode.")
-            response_generator = self.swarm.run(
-                 agent=self.starting_agent, messages=messages, context_variables=self.context_variables,
-                 stream=True, debug=self.debug,
-            )
-            final_response_data = await self._process_and_print_streaming_response_async(response_generator)
-            if self.auto_complete_task:
-                 logger.warning("Auto-completion is not fully supported with streaming in non-interactive mode.")
-        else:
-            logger.debug("Running non-interactive in non-streaming mode.")
-            result = await self.run_with_context_async(messages, self.context_variables)
-            swarm_response = result.get("response")
-            self.context_variables = result.get("context_variables", self.context_variables)
-
-            response_messages = []
-            if hasattr(swarm_response, 'messages'): response_messages = swarm_response.messages
-            elif isinstance(swarm_response, dict) and 'messages' in swarm_response: response_messages = swarm_response.get('messages', [])
-
-            self._pretty_print_response(response_messages)
-            if self.auto_complete_task and self.swarm.agents:
-                logger.debug("Starting auto-completion task.")
-                current_history = messages + response_messages
-                await self._auto_complete_task_async(current_history, stream=False)
-
-        print("--- Execution Completed ---")
-
-    async def _process_and_print_streaming_response_async(self, response_generator):
-        """Async helper to process and print streaming response chunks."""
-        content = ""
-        last_sender = self.context_variables.get("active_agent_name", "Assistant")
-        final_response_chunk_data = None
+             logger.warning(f"Could not determine template path for {self.__class__.__name__}: {e}. Jinja env not created.")
+             self.jinja_env = None
+
+    def render_prompt(self, template_name: str, context: Dict = None) -> str:
+        """Renders a Jinja2 template."""
+        if not self.jinja_env:
+             raise RuntimeError(f"Jinja environment not set up for blueprint {self.__class__.__name__}.")
+        if context is None:
+             context = {}
         try:
-            async for chunk in response_generator:
-                if isinstance(chunk, dict) and "delim" in chunk:
-                    if chunk["delim"] == "start" and not content:
-                        print(f"\033[94m{last_sender}\033[0m: ", end="", flush=True)
-                    elif chunk["delim"] == "end" and content:
-                        print()
-                        content = ""
-                elif hasattr(chunk, 'choices') and chunk.choices:
-                     delta = chunk.choices[0].delta
-                     if delta and delta.content:
-                          print(delta.content, end="", flush=True)
-                          content += delta.content
-                elif isinstance(chunk, dict) and "response" in chunk:
-                     final_response_chunk_data = chunk["response"]
-                     if hasattr(final_response_chunk_data, 'agent'):
-                          last_sender = get_agent_name(final_response_chunk_data.agent)
-                     if hasattr(final_response_chunk_data, 'context_variables'):
-                          self.context_variables.update(final_response_chunk_data.context_variables)
-                     logger.debug("Received final aggregated response chunk in stream.")
-                elif isinstance(chunk, dict) and "error" in chunk:
-                    logger.error(f"Error received during stream: {chunk['error']}")
-                    print(f"\n[Stream Error: {chunk['error']}]")
+             template = self.jinja_env.get_template(template_name)
+             full_context = {**self.params, **context}
+             return template.render(full_context)
         except Exception as e:
-            logger.error(f"Error processing stream: {e}", exc_info=True)
-            print("\n[Error during streaming output]")
-        finally:
-            if content: print()
-        return final_response_chunk_data
-
-    async def _auto_complete_task_async(self, current_history: List[Dict[str, str]], stream: bool) -> None:
-        """Async helper for task auto-completion loop (non-streaming)."""
-        max_auto_turns = 10
-        auto_turn = 0
-        while auto_turn < max_auto_turns:
-            auto_turn += 1
-            logger.debug(f"Auto-completion Turn: {auto_turn}/{max_auto_turns}")
-            conversation_summary = " ".join(m.get("content", "") for m in current_history[-4:] if m.get("content"))
-            last_assistant_msg = next((m.get("content", "") for m in reversed(current_history) if m.get("role") == "assistant" and m.get("content")), "")
-            user_goal = self.context_variables.get("user_goal", "")
-
-            # Call the renamed async method
-            if await self._is_task_done_async(user_goal, conversation_summary, last_assistant_msg):
-                print("\033[93m[System]\033[0m: Task detected as complete.")
-                break
-
-            logger.debug("Task not complete, running next auto-completion turn.")
-            result = await self.run_with_context_async(current_history, self.context_variables)
-            swarm_response = result.get("response")
-            self.context_variables = result.get("context_variables", self.context_variables)
-
-            new_messages = []
-            if hasattr(swarm_response, 'messages'): new_messages = swarm_response.messages
-            elif isinstance(swarm_response, dict) and 'messages' in swarm_response: new_messages = swarm_response.get('messages', [])
-
-            if not new_messages:
-                 logger.warning("Auto-completion turn yielded no new messages. Stopping.")
-                 break
-
-            self._pretty_print_response(new_messages)
-            current_history.extend(new_messages)
-
-        if auto_turn >= max_auto_turns:
-             logger.warning("Auto-completion reached maximum turns limit.")
-             print("\033[93m[System]\033[0m: Reached max auto-completion turns.")
+             logger.error(f"Error rendering template '{template_name}': {e}", exc_info=True)
+             raise
 
-    def _auto_complete_task(self, messages: List[Dict[str, str]], stream: bool) -> None:
-        """Synchronous wrapper for task auto-completion."""
-        if stream:
-             logger.warning("Auto-completion skipped because streaming is enabled.")
-             return
-        logger.debug("Starting synchronous auto-completion task.")
-        try:
-             asyncio.run(self._auto_complete_task_async(messages, stream=False))
-        except RuntimeError as e:
-             if "cannot be called from a running event loop" in str(e):
-                  logger.error("Cannot start _auto_complete_task with asyncio.run from an existing event loop.")
-             else: raise e
-
-    # --- Class Method for Entry Point ---
-    @classmethod
-    def main(cls):
-        parser = argparse.ArgumentParser(description=f"Run the {cls.__name__} blueprint.")
-        parser.add_argument("--config", default="./swarm_config.json", help="Path to the swarm_config.json file.")
-        parser.add_argument("--instruction", help="Single instruction for non-interactive mode.")
-        parser.add_argument("--stream", action="store_true", help="Enable streaming output in non-interactive mode.")
-        parser.add_argument("--auto-complete-task", action="store_true", help="Enable task auto-completion in non-interactive mode.")
-        parser.add_argument("--update-user-goal", action="store_true", help="Enable dynamic goal updates using LLM.")
-        parser.add_argument("--update-user-goal-frequency", type=int, default=5, help="Frequency (in messages) for updating user goal.")
-        parser.add_argument("--log-file-path", help="Path for logging output (default: ~/.swarm/logs/<blueprint_name>.log).")
-        parser.add_argument("--debug", action="store_true", help="Enable debug logging to console instead of file.")
-        parser.add_argument("--use-markdown", action="store_true", help="Enable markdown rendering for assistant responses.")
-        args = parser.parse_args()
-
-        root_logger = logging.getLogger()
-        log_level = logging.DEBUG if args.debug or DEBUG else logging.INFO
-        root_logger.setLevel(log_level)
-
-        if root_logger.hasHandlers(): root_logger.handlers.clear()
-
-        log_formatter = logging.Formatter("[%(asctime)s] [%(levelname)s] %(name)s:%(lineno)d - %(message)s")
-        log_handler = logging.StreamHandler(sys.stdout) if args.debug else logging.FileHandler(
-            Path(args.log_file_path or Path.home() / ".swarm" / "logs" / f"{cls.__name__.lower()}.log").resolve(), mode='a'
-        )
-        log_handler.setFormatter(log_formatter)
-        root_logger.addHandler(log_handler)
-        logger.info(f"Logging initialized. Level: {logging.getLevelName(log_level)}. Destination: {getattr(log_handler, 'baseFilename', 'console')}")
-
-        original_stderr = sys.stderr
-        dev_null = None
-        if not args.debug:
-            try:
-                dev_null = open(os.devnull, "w")
-                sys.stderr = dev_null
-                logger.info(f"Redirected stderr to {os.devnull}")
-            except OSError as e: logger.warning(f"Could not redirect stderr: {e}")
-
-        try:
-            config_data = load_server_config(args.config)
-            blueprint_instance = cls(
-                config=config_data, auto_complete_task=args.auto_complete_task, update_user_goal=args.update_user_goal,
-                update_user_goal_frequency=args.update_user_goal_frequency, log_file_path=str(getattr(log_handler, 'baseFilename', None)),
-                debug=args.debug, use_markdown=args.use_markdown, non_interactive=bool(args.instruction)
-            )
-            if args.instruction:
-                 asyncio.run(blueprint_instance.non_interactive_mode_async(args.instruction, stream=args.stream))
-            else:
-                blueprint_instance.interactive_mode(stream=args.stream)
-        except Exception as e:
-             logger.critical(f"Blueprint execution failed: {e}", exc_info=True)
-             print(f"Critical Error: {e}", file=original_stderr)
-        finally:
-             if not args.debug and dev_null is not None:
-                 sys.stderr = original_stderr
-                 dev_null.close()
-                 logger.debug("Restored stderr.")
-             logger.info("Blueprint execution finished.")
+    def get_llm_profile(self) -> Dict:
+         """Returns the configuration for the LLM profile being used."""
+         if not hasattr(self, 'llm_profile'):
+              logger.warning("LLM profile was not set during initialization, returning empty dict.")
+              return {}
+         return self.llm_profile
 
-if __name__ == "__main__":
-    BlueprintBase.main()