open-swarm 0.1.1748636259__py3-none-any.whl → 0.1.1748636295__py3-none-any.whl

swarm/extensions/blueprint/blueprint_base.py

@@ -1,69 +1,41 @@
 """
-Swarm Blueprint Base Module (Sync Interactive Mode) - Updated to Use openai-agents
-
-This module provides the base class for blueprints with interactive and non-interactive modes.
-It has been refactored to use the openai-agents Runner for agent execution instead of the legacy Swarm core.
-Additionally, it initializes the mcp_servers attribute from the configuration and manages context variables.
-Since the original swarm.types module has been removed, minimal ChatMessage and Response classes are defined here.
+Swarm Blueprint Base Module (Sync Interactive Mode)
 """
 
 import asyncio
 import json
 import logging
-from abc import ABC, abstractmethod
-from pathlib import Path
-from typing import Optional, Dict, Any, List
-
+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 sys
 import uuid
+import sys
+from abc import ABC, abstractmethod
+from typing import Optional, Dict, Any, List
 
+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.message_sequence import repair_message_payload, validate_message_sequence
-from swarm.utils.context_utils import truncate_message_history
-from swarm.extensions.blueprint.agent_utils import get_agent_name, initialize_agents
+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
-
-class DummyMCPServer:
-    async def list_tools(self) -> list:
-        return []
-
-# Import Runner and Agent from the openai-agents SDK.
-from agents import Runner  # type: ignore
-from agents.agent import Agent  # type: ignore
-
-# Minimal definitions to replace swarm.types
-from dataclasses import dataclass
-
-@dataclass
-class ChatMessage:
-    role: str
-    content: str
-
-@dataclass
-class Response:
-    messages: List[ChatMessage]
-    agent: Optional[Any]
-    context_variables: Dict[str, Any]
+from swarm.types import Agent, Response
 
 logger = logging.getLogger(__name__)
 
 class BlueprintBase(ABC):
-    """
-    Base class for blueprints using the openai-agents Runner for execution.
-    Agents are expected to be created via create_agents() and stored in self.agents.
-    Runner.run() is used to execute agents with a plain text input.
-    
-    This version initializes mcp_servers from the configuration and restores context_variables.
-    """
-    
-    # Set up initial context variables as a class variable.
-    context_variables: Dict[str, Any] = {"user_goal": ""}
+    """Base class for Swarm blueprints with sync interactive mode and Django integration."""
 
     def __init__(
         self,
@@ -87,372 +59,504 @@ class BlueprintBase(ABC):
         self.log_file_path = log_file_path
         self.debug = debug or DEBUG
         self.use_markdown = use_markdown
-        self._urls_registered = False  # For Django URL registration
+        self._urls_registered = False
 
         if self.use_markdown:
-            logger.debug("Markdown rendering enabled.")
+            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):
-            try:
-                _ = self.metadata
-                if not isinstance(self.metadata, dict):
-                    raise TypeError("Metadata is not a dict")
-            except (AttributeError, NotImplementedError, TypeError) as e:
-                raise AssertionError(f"{self.__class__.__name__} must define a 'metadata' property returning a dictionary. Error: {e}")
+        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.")
 
         self.truncation_mode = os.getenv("SWARM_TRUNCATION_MODE", "pairs").lower()
-        meta = self.metadata
-        self.max_context_tokens = max(1, meta.get("max_context_tokens", 8000))
-        self.max_context_messages = max(1, meta.get("max_context_messages", 50))
+        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}")
 
         load_dotenv()
-        logger.debug("Loaded environment variables from .env (if present).")
+        logger.debug("Loaded environment variables from .env.")
 
         self.config = config
-        # Initialize mcp_servers from configuration.
-        self.mcp_servers: Dict[str, Any] = {}
-        if "mcp_servers" in self.config:
-            self.mcp_servers = load_server_config(self.config["mcp_servers"])
-            logger.debug(f"Loaded mcp_servers: {list(self.mcp_servers.keys())}")
-        else:
-            logger.debug("No mcp_servers configuration found.")
-
-        # Set default mcp server configurations if keys are missing.
-        if "mcp_llms_txt_server" not in self.mcp_servers:
-            logger.warning("mcp_llms_txt_server not found in mcp_servers; using default dummy configuration.")
-            self.mcp_servers["mcp_llms_txt_server"] = {"command": "echo", "args": [], "env": {}}
-        if "everything_server" not in self.mcp_servers:
-            logger.warning("everything_server not found in mcp_servers; using default dummy configuration.")
-            self.mcp_servers["everything_server"] = {"command": "echo", "args": [], "env": {}}
-
         self.skip_django_registration = skip_django_registration or not os.environ.get("DJANGO_SETTINGS_MODULE")
-        # Initialize agents.
-        initialized_agents = initialize_agents(self)  # type: ignore
-        self.agents: Dict[str, Agent] = initialized_agents if initialized_agents is not None else {}
-        # Restore context_variables on the instance.
-        self.context_variables = {"user_goal": ""}
-        self.starting_agent: Optional[Agent] = None
+        self.swarm = kwargs.get('swarm_instance') or Swarm(config=self.config, debug=self.debug)
+        logger.debug("Swarm instance initialized.")
 
+        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))
+        self.spinner = Spinner(interactive=not kwargs.get('non_interactive', False))
 
-        required_env_vars = set(meta.get("env_vars", []))
+        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 {meta.get('title', self.__class__.__name__)}: {', '.join(missing_vars)}")
+            logger.warning(f"Missing environment variables for {self.metadata.get('title', self.__class__.__name__)}: {', '.join(missing_vars)}")
 
-        self.required_mcp_servers = meta.get("required_mcp_servers", [])
-        logger.debug(f"Required MCP servers from metadata: {self.required_mcp_servers}")
+        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():
-            initialized_agents = initialize_agents(self)  # type: ignore
-            self.agents = initialized_agents if initialized_agents is not None else {}
+            initialize_agents(self)
         register_django_components(self)
 
     def _is_create_agents_overridden(self) -> bool:
-        return getattr(self.__class__, "create_agents") is not getattr(BlueprintBase, "create_agents")
+        """Check if the 'create_agents' method is overridden in the subclass."""
+        return self.__class__.create_agents is not BlueprintBase.create_agents
 
     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)
 
     @property
     @abstractmethod
     def metadata(self) -> Dict[str, Any]:
-        raise NotImplementedError("Subclasses must implement the 'metadata' property.")
+        """Abstract property for blueprint metadata."""
+        raise NotImplementedError
 
     def create_agents(self) -> Dict[str, Agent]:
-        logger.debug(f"{self.__class__.__name__} using default create_agents (returns empty dict). Override if agents are needed.")
+        """Default agent creation method."""
         return {}
 
     def set_starting_agent(self, agent: Agent) -> None:
-        agent_name = get_agent_name(agent)  # type: ignore
+        """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
-        # Only track the active agent if handoffs are defined (indicating async runner usage).
-        if hasattr(agent, "handoffs"):
-            self.context_variables["active_agent_name"] = agent_name
+        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")
-        if active_agent_name and active_agent_name in self.agents:
-            logger.debug(f"Active agent determined: {active_agent_name}")
-            return self.agents[active_agent_name]
-        elif self.starting_agent is not None:
-            agent_to_use = self.starting_agent
-            starting_agent_name = get_agent_name(agent_to_use)  # type: ignore
-            if active_agent_name != starting_agent_name:
-                logger.warning(f"Active agent name '{active_agent_name}' invalid; defaulting to starting agent: {starting_agent_name}")
-                self.context_variables["active_agent_name"] = starting_agent_name
-            else:
-                logger.debug(f"Using starting agent: {starting_agent_name}")
-            return agent_to_use
-        elif self.agents:
-            first_agent_name = next(iter(self.agents))
-            logger.warning(f"No active agent set. Defaulting to first registered agent: {first_agent_name}")
-            self.context_variables["active_agent_name"] = first_agent_name
-            return self.agents[first_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("No agents registered in blueprint.")
-            return None
-
-    def run_with_context(self, messages: List[Dict[str, Any]], context_variables: dict) -> dict:
-        dict_messages = []
-        for msg in messages:
-            if hasattr(msg, "model_dump"):
-                dict_messages.append(msg.model_dump(exclude_none=True))  # type: ignore
-            elif isinstance(msg, dict):
-                dict_messages.append(msg)
-            else:
-                logger.warning(f"Skipping non-dict message: {type(msg)}")
-                continue
-        return asyncio.run(self.run_with_context_async(dict_messages, context_variables))
-
-    async def run_with_context_async(self, messages: List[Dict[str, Any]], context_variables: dict) -> dict:
+             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: {list(self.context_variables.keys())}")
+        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 available.")
-            error_msg = ChatMessage(role="assistant", content="Error: No active agent available.")
-            return {
-                "response": Response(messages=[error_msg], agent=None, context_variables=self.context_variables),
-                "context_variables": self.context_variables
-            }
-        input_text = " ".join(msg.get("content", "") for msg in messages if "content" in msg)
-        if not input_text:
-            logger.warning("No valid input found in messages.")
-            input_text = ""
-        logger.debug(f"Running Runner with agent {get_agent_name(active_agent)} and input: {input_text[:100]}...")
+            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:
-            result = await Runner.run(active_agent, input_text)  # type: ignore
+            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"Runner.run failed: {e}", exc_info=True)
-            error_msg = ChatMessage(role="assistant", content=f"Error: {str(e)}")
-            result = Response(messages=[error_msg], agent=active_agent, context_variables=self.context_variables)
+            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()
-        return {"response": result, "context_variables": updated_context}
+
+        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:
-        if agent_name in self.agents:
+        """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
-            logger.debug(f"Active agent set to: {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"Agent '{agent_name}' not found. Available: {list(self.agents.keys())}")
+            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("Empty user_goal; cannot check task completion.")
-            return False
-        system_prompt = os.getenv("TASK_DONE_PROMPT", "You are a completion checker. Answer ONLY YES or NO.")
+             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 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 = Runner.client  # type: ignore
-        model_to_use = Runner.current_llm_config.get("model", Runner.model)  # type: ignore
+            "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:
-            if not client:
-                raise ValueError("Runner client not available.")
             response = await client.chat.completions.create(
-                model=model_to_use,
-                messages=check_prompt,
-                max_tokens=5,
-                temperature=0
+                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: {is_done} (raw: '{result_content}')")
-                return is_done
+                 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("No choices in LLM response for task completion check.")
-                return False
+                 logger.warning("LLM response for task completion check had no choices.")
+                 return False
         except Exception as e:
-            logger.error(f"Task completion check failed: {e}", exc_info=True)
+            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, Any]]) -> None:
+    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("No messages provided for goal update.")
+            logger.debug("Cannot update goal: No messages provided.")
             return
+
         system_prompt = os.getenv(
             "UPDATE_GOAL_PROMPT",
-            "Summarize the user's primary objective from the conversation in one sentence."
-        )
-        conversation_text = "\n".join(
-            f"{m.get('sender', m.get('role', ''))}: {m.get('content', '') or '[Tool Call]'}"
-            for m in messages if m.get("content") or m.get("tool_calls")
+            "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("No usable conversation content for goal update.")
-            return
+             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[-2000:])
-        prompt = [
-            {"role": "system", "content": system_prompt},
-            {"role": "user", "content": user_prompt}
-        ]
-        client = Runner.client  # type: ignore
-        model_to_use = Runner.current_llm_config.get("model", Runner.model)  # type: ignore
+        ).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)
+
         try:
-            if not client:
-                raise ValueError("Runner client not available for goal update.")
             response = await client.chat.completions.create(
-                model=model_to_use,
-                messages=prompt,
-                max_tokens=60,
-                temperature=0.3
+                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 and new_goal != self.context_variables.get("user_goal"):
-                    self.context_variables["user_goal"] = new_goal
-                    logger.info(f"Updated user goal: {new_goal}")
-                elif not new_goal:
-                    logger.warning("LLM returned an empty goal for update.")
-                else:
-                    logger.debug("LLM goal update produced the same goal.")
+                 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.")
             else:
-                logger.warning("No choices in LLM response for goal update.")
+                 logger.warning("LLM response for goal update had no choices.")
         except Exception as e:
-            logger.error(f"Goal update failed: {e}", exc_info=True)
+            logger.error(f"User goal update LLM call failed: {e}", exc_info=True)
 
     def task_completed(self, outcome: str) -> None:
-        print(f"\n\033[93m[System Task Outcome]\033[0m: {outcome}")
+        """Placeholder method potentially used by agents to signal task completion."""
+        print(f"Task Outcome: {outcome}")
+        print("continue")
 
     @property
     def prompt(self) -> str:
-        active_agent_name = self.context_variables.get("active_agent_name")
-        active_agent = self.agents.get(active_agent_name) if active_agent_name else None
-        if active_agent:
-            return f"{get_agent_name(active_agent)} > "
-        else:
-            return "User: "
+        """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:
-        try:
-            from .interactive_mode import run_interactive_mode
-            run_interactive_mode(self, stream)
-        except ImportError:
-            logger.critical("Failed to import interactive_mode runner.")
-            print("Error: Cannot start interactive mode.", file=sys.stderr)
+        """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))
+             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("Non-interactive mode cannot run within an async context.")
-                print("Error: Non-interactive mode cannot run within an async context.", file=sys.stderr)
-            else:
-                raise e
-        except Exception as e:
-            logger.error(f"Error during non-interactive mode: {e}", exc_info=True)
-            print(f"Error: {e}", file=sys.stderr)
+             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.agents:
-            logger.error("No agents available in blueprint instance.")
-            print("Error: No agents available.", file=sys.stderr)
+        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
+             print("No valid instruction provided.")
+             return
+        messages = [{"role": "user", "content": line} for line in instructions]
 
-        messages: List[Dict[str, Any]] = [{"role": "user", "content": line} for line in instructions]
         if not self.starting_agent:
-            if self.agents:
-                first_agent_name = next(iter(self.agents.keys()))
-                logger.warning(f"No starting agent set. Defaulting to first agent: {first_agent_name}")
-                self.set_starting_agent(self.agents[first_agent_name])
-            else:
-                logger.error("No starting agent set and no agents defined.")
-                print("Error: No agent available.", file=sys.stderr)
-                return
+             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
-        if "active_agent_name" not in self.context_variables:
-            self.context_variables["active_agent_name"] = get_agent_name(self.starting_agent)  # type: ignore
+        self.context_variables["active_agent_name"] = get_agent_name(self.starting_agent)
 
         if stream:
             logger.debug("Running non-interactive in streaming mode.")
-            active_agent = await self.determine_active_agent()
-            if not active_agent:
-                return
-            response_generator = Runner.run(active_agent, " ".join(m.get("content", "") for m in messages))  # type: ignore
-            await self._process_and_print_streaming_response_async(response_generator)
+            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 with streaming is not fully supported.")
+                 logger.warning("Auto-completion is not fully supported with streaming in non-interactive mode.")
         else:
             logger.debug("Running non-interactive in non-streaming mode.")
-            input_text = " ".join(m.get("content", "") for m in messages)
-            result = await Runner.run(self.starting_agent, input_text)  # type: ignore
-            if hasattr(result, "final_output"):
-                print(f"\nFinal response:\n{result.final_output}")
-            else:
-                print("Received unexpected response format.")
+            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) -> Optional[Dict[str, Any]]:
-        full_content = ""
-        async for chunk in response_generator:
-            if "error" in chunk:
-                logger.error(f"Streaming error: {chunk['error']}")
-                print(f"Error: {chunk['error']}", file=sys.stderr)
+    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
+        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']}]")
+        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
-            if "choices" in chunk:
-                for choice in chunk["choices"]:
-                    delta = choice.get("delta", {}).get("content", "")
-                    full_content += delta
-                    print(delta, end="", flush=True)
-        print()
-        return None
-
-    async def _auto_complete_task_async(self, current_history: List[Dict[str, Any]], stream: bool) -> None:
-        logger.debug("Auto-complete task not implemented.")
-        pass
 
+            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.")
+
+    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 configuration file.")
-        parser.add_argument("--instruction", help="Instruction for non-interactive mode.")
-        parser.add_argument("--stream", action="store_true", help="Enable streaming mode.")
+        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()
-        if not os.path.exists(args.config):
-            logger.error(f"Configuration file {args.config} not found.")
-            sys.exit(1)
+
+        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:
-            with open(args.config, "r") as f:
-                config = json.load(f)
+            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.error(f"Failed to load configuration: {e}")
-            sys.exit(1)
-        blueprint_instance = cls(config=config)
-        if args.instruction:
-            blueprint_instance.non_interactive_mode(instruction=args.instruction, stream=args.stream)
-        else:
-            blueprint_instance.interactive_mode(stream=args.stream)
+             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.")
 
 if __name__ == "__main__":
     BlueprintBase.main()