autobyteus 1.1.3__py3-none-any.whl → 1.1.4__py3-none-any.whl

autobyteus/tools/registry/tool_definition.py

@@ -6,7 +6,7 @@ from typing import Dict, Any, List as TypingList, Type, TYPE_CHECKING, Optional,
 from autobyteus.llm.providers import LLMProvider
 from autobyteus.tools.tool_config import ToolConfig
 from autobyteus.tools.parameter_schema import ParameterSchema
-from autobyteus.tools.tool_category import ToolCategory
+from autobyteus.tools.tool_origin import ToolOrigin
 from autobyteus.tools.usage.providers import (
     XmlSchemaProvider, 
     JsonSchemaProvider, 
@@ -28,7 +28,8 @@ class ToolDefinition:
                  name: str,
                  description: str,
                  argument_schema: Optional['ParameterSchema'],
-                 category: ToolCategory,
+                 origin: ToolOrigin,
+                 category: str,
                  config_schema: Optional['ParameterSchema'] = None,
                  tool_class: Optional[Type['BaseTool']] = None,
                  custom_factory: Optional[Callable[['ToolConfig'], 'BaseTool']] = None,
@@ -55,12 +56,12 @@ class ToolDefinition:
              raise TypeError(f"ToolDefinition '{name}' received an invalid 'argument_schema'. Expected ParameterSchema or None.")
         if config_schema is not None and not isinstance(config_schema, ParameterSchema):
              raise TypeError(f"ToolDefinition '{name}' received an invalid 'config_schema'. Expected ParameterSchema or None.")
-        if not isinstance(category, ToolCategory):
-            raise TypeError(f"ToolDefinition '{name}' requires a ToolCategory for 'category'. Got {type(category)}")
+        if not isinstance(origin, ToolOrigin):
+            raise TypeError(f"ToolDefinition '{name}' requires a ToolOrigin for 'origin'. Got {type(origin)}")
         
         # Validation for MCP-specific metadata
-        if category == ToolCategory.MCP and not (metadata and metadata.get("mcp_server_id")):
-            raise ValueError(f"ToolDefinition '{name}' with category MCP must provide a 'mcp_server_id' in its metadata.")
+        if origin == ToolOrigin.MCP and not (metadata and metadata.get("mcp_server_id")):
+            raise ValueError(f"ToolDefinition '{name}' with origin MCP must provide a 'mcp_server_id' in its metadata.")
 
         self._name = name
         self._description = description
@@ -68,6 +69,7 @@ class ToolDefinition:
         self._config_schema: Optional['ParameterSchema'] = config_schema
         self._tool_class = tool_class
         self._custom_factory = custom_factory
+        self._origin = origin
         self._category = category
         self._metadata = metadata or {}
         
@@ -87,7 +89,9 @@ class ToolDefinition:
     @property
     def config_schema(self) -> Optional['ParameterSchema']: return self._config_schema
     @property
-    def category(self) -> ToolCategory: return self._category
+    def origin(self) -> ToolOrigin: return self._origin
+    @property
+    def category(self) -> str: return self._category
     @property
     def metadata(self) -> Dict[str, Any]: return self._metadata
     
@@ -145,4 +149,4 @@ class ToolDefinition:
     def __repr__(self) -> str:
         creator_repr = f"class='{self._tool_class.__name__}'" if self._tool_class else "factory=True"
         metadata_repr = f", metadata={self.metadata}" if self.metadata else ""
-        return (f"ToolDefinition(name='{self.name}', category='{self.category.value}'{metadata_repr}, {creator_repr})")
+        return (f"ToolDefinition(name='{self.name}', origin='{self.origin.value}', category='{self.category}'{metadata_repr}, {creator_repr})")

autobyteus/tools/registry/tool_registry.py

@@ -1,11 +1,12 @@
 # file: autobyteus/tools/registry/tool_registry.py
 import logging
 from typing import Dict, List, Optional, Type, TYPE_CHECKING
+from collections import defaultdict
 
 from autobyteus.tools.registry.tool_definition import ToolDefinition
 from autobyteus.utils.singleton import SingletonMeta
 from autobyteus.tools.tool_config import ToolConfig
-from autobyteus.tools.tool_category import ToolCategory
+from autobyteus.tools.tool_origin import ToolOrigin
 
 if TYPE_CHECKING:
     from autobyteus.tools.base_tool import BaseTool
@@ -141,7 +142,54 @@ class ToolRegistry(metaclass=SingletonMeta):
         
         return [
             td for td in self._definitions.values()
-            if td.category == ToolCategory.MCP and td.metadata.get("mcp_server_id") == server_id
+            if td.origin == ToolOrigin.MCP and td.metadata.get("mcp_server_id") == server_id
         ]
 
+    def get_tools_by_category(self, category: str) -> List[ToolDefinition]:
+        """
+        Returns a list of all registered tool definitions that match a specific category.
+
+        Args:
+            category: The category string to filter by.
+
+        Returns:
+            A list of matching ToolDefinition objects, sorted by name.
+        """
+        if not category:
+            return []
+        
+        matching_tools = [
+            td for td in self._definitions.values() if td.category == category
+        ]
+        return sorted(matching_tools, key=lambda td: td.name)
+
+    def get_tools_grouped_by_category(self, origin: Optional[ToolOrigin] = None) -> Dict[str, List[ToolDefinition]]:
+        """
+        Returns all registered tool definitions, grouped into a dictionary by their category.
+        Can optionally filter by tool origin before grouping.
+
+        Args:
+            origin: If provided, only tools from this origin will be included.
+
+        Returns:
+            A dictionary where keys are category strings and values are lists
+            of ToolDefinition objects belonging to that category. Both the categories
+            and the tools within each category are sorted alphabetically.
+        """
+        grouped_tools = defaultdict(list)
+        
+        tools_to_process = self._definitions.values()
+        if origin:
+            tools_to_process = [td for td in tools_to_process if td.origin == origin]
+
+        for td in tools_to_process:
+            grouped_tools[td.category].append(td)
+        
+        # Sort tools within each category and sort the categories themselves for deterministic output
+        sorted_grouped_tools = {}
+        for category in sorted(grouped_tools.keys()):
+            sorted_grouped_tools[category] = sorted(grouped_tools[category], key=lambda td: td.name)
+            
+        return sorted_grouped_tools
+
 default_tool_registry = ToolRegistry()

autobyteus/tools/timer.py

@@ -3,6 +3,7 @@ from typing import Optional, TYPE_CHECKING, Any
 from autobyteus.tools.base_tool import BaseTool
 from autobyteus.tools.tool_config import ToolConfig 
 from autobyteus.tools.parameter_schema import ParameterSchema, ParameterDefinition, ParameterType 
+from autobyteus.tools.tool_category import ToolCategory
 from autobyteus.events.event_emitter import EventEmitter 
 from autobyteus.events.event_types import EventType
 import logging 
@@ -17,6 +18,7 @@ class Timer(BaseTool, EventEmitter):
     A tool that provides timer functionality with configurable duration and event emission.
     The timer runs independently after being started and emits TIMER_UPDATE events.
     """
+    CATEGORY = ToolCategory.UTILITY
 
     def __init__(self, config: Optional[ToolConfig] = None):
         BaseTool.__init__(self, config=config)

autobyteus/tools/tool_category.py

@@ -2,10 +2,20 @@
 from enum import Enum
 
 class ToolCategory(str, Enum):
-    """Enumeration of tool categories to identify their origin."""
-    LOCAL = "local"
-    MCP = "mcp"
-    # BUILT_IN, USER_DEFINED etc. could be added later.
+    """
+    Provides standardized string constants for common tool categories.
+    While tools can use any string for a category, using these constants
+    is recommended to ensure consistency in UI grouping.
+    """
+    USER_INTERACTION = "User Interaction"
+    FILE_SYSTEM = "File System"
+    WEB = "Web"
+    SYSTEM = "System"
+    UTILITY = "Utility"
+    AGENT_COMMUNICATION = "Agent Communication"
+    PROMPT_MANAGEMENT = "Prompt Management"
+    GENERAL = "General"
+    MCP = "MCP"
 
     def __str__(self) -> str:
         return self.value

autobyteus/tools/tool_meta.py

@@ -5,6 +5,7 @@ from typing import Dict, Any
 
 from autobyteus.tools.registry import default_tool_registry, ToolDefinition
 from autobyteus.tools.parameter_schema import ParameterSchema
+from autobyteus.tools.tool_origin import ToolOrigin
 from autobyteus.tools.tool_category import ToolCategory
 
 logger = logging.getLogger(__name__)
@@ -53,6 +54,9 @@ class ToolMeta(ABCMeta):
                         instantiation_config_schema = None
                 except Exception as e:
                     logger.warning(f"Tool class {name} ({tool_name}) has get_config_schema() but it failed: {e}. Assuming no instantiation config.")
+
+            # Get category from class attribute, defaulting to "General"
+            category_str = getattr(cls, 'CATEGORY', ToolCategory.GENERAL)
             
             # Create the definition without pre-generating usage strings
             definition = ToolDefinition(
@@ -62,7 +66,8 @@ class ToolMeta(ABCMeta):
                 custom_factory=None,
                 argument_schema=argument_schema,
                 config_schema=instantiation_config_schema,
-                category=ToolCategory.LOCAL
+                origin=ToolOrigin.LOCAL,
+                category=category_str
             )
             default_tool_registry.register_tool(definition)
             

autobyteus/tools/tool_origin.py

@@ -0,0 +1,10 @@
+# file: autobyteus/autobyteus/tools/tool_origin.py
+from enum import Enum
+
+class ToolOrigin(str, Enum):
+    """Enumeration of tool origins to identify their execution model."""
+    LOCAL = "local"
+    MCP = "mcp"
+
+    def __str__(self) -> str:
+        return self.value

autobyteus/workflow/agentic_workflow.py

@@ -0,0 +1,93 @@
+# file: autobyteus/autobyteus/workflow/agentic_workflow.py
+import logging
+from typing import Optional
+
+from autobyteus.workflow.runtime.workflow_runtime import WorkflowRuntime
+from autobyteus.workflow.events.workflow_events import ProcessUserMessageEvent, ToolApprovalWorkflowEvent
+from autobyteus.agent.message.agent_input_user_message import AgentInputUserMessage
+from autobyteus.workflow.phases.workflow_operational_phase import WorkflowOperationalPhase
+
+logger = logging.getLogger(__name__)
+
+class AgenticWorkflow:
+    """
+    User-facing facade for interacting with a managed workflow.
+    This class is a lightweight wrapper around a WorkflowRuntime instance
+    and is typically created by a WorkflowFactory.
+    """
+    def __init__(self, runtime: WorkflowRuntime):
+        """
+        Initializes the AgenticWorkflow facade.
+
+        Args:
+            runtime: The pre-configured and ready-to-use runtime for the workflow.
+        """
+        if not isinstance(runtime, WorkflowRuntime):
+            raise TypeError(f"AgenticWorkflow requires a WorkflowRuntime instance, got {type(runtime).__name__}")
+        
+        self._runtime = runtime
+        self.workflow_id: str = self._runtime.context.workflow_id
+        logger.info(f"AgenticWorkflow facade created for workflow ID '{self.workflow_id}'.")
+
+    @property
+    def name(self) -> str:
+        return self._runtime.context.config.name
+
+    @property
+    def role(self) -> Optional[str]:
+        """The role of the workflow, for when it's used as a sub-workflow."""
+        return self._runtime.context.config.role
+
+    async def post_message(self, message: AgentInputUserMessage, target_agent_name: Optional[str] = None) -> None:
+        """
+        Submits a message to the workflow, routing it to a specific node (agent or sub-workflow).
+        If `target_agent_name` is not provided, the message is sent to the workflow's coordinator.
+        """
+        final_target_name = target_agent_name or self._runtime.context.config.coordinator_node.name
+        logger.info(f"Workflow '{self.workflow_id}': post_message called. Target: '{final_target_name}'.")
+
+        if not self._runtime.is_running:
+            self.start()
+        
+        event = ProcessUserMessageEvent(
+            user_message=message,
+            target_agent_name=final_target_name
+        )
+        await self._runtime.submit_event(event)
+
+    async def post_tool_execution_approval(
+        self,
+        agent_name: str,
+        tool_invocation_id: str,
+        is_approved: bool,
+        reason: Optional[str] = None
+    ):
+        """Submits a tool execution approval/denial to a specific agent in the workflow."""
+        logger.info(f"Workflow '{self.workflow_id}': post_tool_execution_approval called for agent '{agent_name}'. Approved: {is_approved}.")
+        if not self._runtime.is_running:
+            logger.warning(f"Workflow '{self.workflow_id}' is not running. Cannot post approval.")
+            return
+
+        event = ToolApprovalWorkflowEvent(
+            agent_name=agent_name,
+            tool_invocation_id=tool_invocation_id,
+            is_approved=is_approved,
+            reason=reason,
+        )
+        await self._runtime.submit_event(event)
+
+    def start(self) -> None:
+        """Starts the workflow's background worker thread."""
+        self._runtime.start()
+
+    async def stop(self, timeout: float = 10.0) -> None:
+        """Stops the workflow and all its agents."""
+        await self._runtime.stop(timeout)
+
+    @property
+    def is_running(self) -> bool:
+        """Checks if the workflow's worker is running."""
+        return self._runtime.is_running
+        
+    def get_current_phase(self) -> WorkflowOperationalPhase: 
+        return self._runtime.context.state.current_phase

autobyteus/{agent/workflow → workflow}/base_agentic_workflow.py

@@ -1,31 +1,33 @@
-# file: autobyteus/autobyteus/agent/workflow/base_agentic_workflow.py
+# file: autobyteus/autobyteus/workflow/base_agentic_workflow.py
 import logging
 from abc import ABC, abstractmethod
-from typing import Optional, Any, Union
+from typing import Optional, Any, TYPE_CHECKING
 
-from autobyteus.agent.workflow.agentic_workflow import AgenticWorkflow
-from autobyteus.agent.group.agent_group import AgentGroup
+# These are forward declarations that might be used by subclasses.
+# The actual circular dependency is avoided by type-hinting strings.
+if TYPE_CHECKING:
+    from autobyteus.workflow.agentic_workflow import AgenticWorkflow
+    from autobyteus.agent.group import AgentGroup
 
 logger = logging.getLogger(__name__)
 
 class BaseAgenticWorkflow(ABC):
     """
-    FR28: Optional abstract base class for creating domain-specific, type-safe
+    Optional abstract base class for creating domain-specific, type-safe
     APIs for agentic workflows.
 
-    FR29: Users can subclass BaseAgenticWorkflow if they wish to create a more
-    structured and specific interface for their multi-agent tasks, rather than
-    using the generic `AgenticWorkflow.process(**kwargs)` method directly.
+    Users can subclass BaseAgenticWorkflow to create a more structured and
+    specific interface for their multi-agent tasks, rather than using the
+    generic `AgenticWorkflow.process(**kwargs)` method directly.
 
-    FR30: Subclasses would typically encapsulate an `AgenticWorkflow` instance
-    or an `AgentGroup` instance directly. They then define methods that map
-    domain-specific inputs to the underlying workflow's execution, providing
-    type safety and a clearer API for that particular workflow.
+    Subclasses would typically encapsulate an `AgenticWorkflow` or an `AgentGroup`
+    instance and define methods that map domain-specific inputs to the
+    underlying workflow's execution.
     """
 
     def __init__(self,
                  name: str,
-                 wrapped_workflow_instance: Optional[Union[AgenticWorkflow, AgentGroup]] = None):
+                 wrapped_workflow_instance: Optional[Any] = None):
         """
         Initializes the BaseAgenticWorkflow.
 
@@ -37,7 +39,7 @@ class BaseAgenticWorkflow(ABC):
                                        workflow/group instance.
         """
         self.name: str = name
-        self._wrapped_workflow: Optional[Union[AgenticWorkflow, AgentGroup]] = wrapped_workflow_instance
+        self._wrapped_workflow: Optional[Any] = wrapped_workflow_instance
         
         if self._wrapped_workflow:
             logger.info(f"BaseAgenticWorkflow '{self.name}' initialized, wrapping an instance of "
@@ -47,7 +49,7 @@ class BaseAgenticWorkflow(ABC):
                         "Subclass should handle workflow/group setup.")
 
     @property
-    def wrapped_workflow(self) -> Optional[Union[AgenticWorkflow, AgentGroup]]:
+    def wrapped_workflow(self) -> Optional[Any]:
         """Provides access to the wrapped AgenticWorkflow or AgentGroup instance."""
         return self._wrapped_workflow
 
@@ -76,23 +78,13 @@ class BaseAgenticWorkflow(ABC):
         """
         pass
     
-    # Subclasses will define their own domain-specific process methods, for example:
-    # @abstractmethod
-    # async def generate_report(self, topic: str, length_words: int) -> Report:
-    #     pass
-    #
-    # @abstractmethod
-    # async def translate_document(self, document_path: str, target_language: str) -> TranslatedDocument:
-    #     pass
-
     def __repr__(self) -> str:
         running_status = "N/A (not implemented by subclass)"
         try:
             running_status = str(self.is_running)
-        except NotImplementedError: # pragma: no cover
-            pass # Keep default N/A
+        except NotImplementedError:
+            pass
             
         return (f"<{self.__class__.__name__} name='{self.name}', "
                 f"wraps='{self._wrapped_workflow.__class__.__name__ if self._wrapped_workflow else 'NoneInternal'}', "
                 f"is_running={running_status}>")
-

autobyteus/workflow/bootstrap_steps/__init__.py

@@ -0,0 +1,20 @@
+# file: autobyteus/autobyteus/workflow/bootstrap_steps/__init__.py
+"""
+Defines individual, self-contained steps for the workflow bootstrapping process.
+"""
+
+from autobyteus.workflow.bootstrap_steps.base_workflow_bootstrap_step import BaseWorkflowBootstrapStep
+from autobyteus.workflow.bootstrap_steps.workflow_runtime_queue_initialization_step import WorkflowRuntimeQueueInitializationStep
+from autobyteus.workflow.bootstrap_steps.coordinator_prompt_preparation_step import CoordinatorPromptPreparationStep
+from autobyteus.workflow.bootstrap_steps.agent_tool_injection_step import AgentToolInjectionStep
+from autobyteus.workflow.bootstrap_steps.coordinator_initialization_step import CoordinatorInitializationStep
+from autobyteus.workflow.bootstrap_steps.workflow_bootstrapper import WorkflowBootstrapper
+
+__all__ = [
+    "BaseWorkflowBootstrapStep",
+    "WorkflowRuntimeQueueInitializationStep",
+    "CoordinatorPromptPreparationStep",
+    "AgentToolInjectionStep",
+    "CoordinatorInitializationStep",
+    "WorkflowBootstrapper",
+]

autobyteus/workflow/bootstrap_steps/agent_tool_injection_step.py

@@ -0,0 +1,34 @@
+# file: autobyteus/autobyteus/workflow/bootstrap_steps/agent_tool_injection_step.py
+import logging
+from typing import TYPE_CHECKING, Dict, Set
+
+from autobyteus.workflow.bootstrap_steps.base_workflow_bootstrap_step import BaseWorkflowBootstrapStep
+from autobyteus.agent.context import AgentConfig
+from autobyteus.agent.message.send_message_to import SendMessageTo
+from autobyteus.workflow.context.workflow_node_config import WorkflowNodeConfig
+from autobyteus.tools.registry import default_tool_registry
+
+if TYPE_CHECKING:
+    from autobyteus.workflow.context.workflow_context import WorkflowContext
+    from autobyteus.workflow.phases.workflow_phase_manager import WorkflowPhaseManager
+
+logger = logging.getLogger(__name__)
+
+class AgentToolInjectionStep(BaseWorkflowBootstrapStep):
+    """
+    Bootstrap step to inject workflow-aware tools like SendMessageTo into
+    agent configurations just before they are used. This step is now effectively
+    a placeholder as tool injection is handled just-in-time by the TeamManager,
+    but it is kept for potential future use and to maintain the bootstrap sequence structure.
+    The primary logic of applying the coordinator prompt has been moved to the TeamManager
+    to ensure it happens just before the coordinator is created.
+    """
+    async def execute(self, context: 'WorkflowContext', phase_manager: 'WorkflowPhaseManager') -> bool:
+        workflow_id = context.workflow_id
+        logger.info(f"Workflow '{workflow_id}': Executing AgentToolInjectionStep (now a placeholder).")
+        # The logic for injecting SendMessageTo and setting the coordinator prompt is now
+        # handled just-in-time by the TeamManager to better support lazy-loading of nodes.
+        # This step is preserved in the bootstrap sequence for clarity and future expansion.
+        logger.debug(f"Workflow '{workflow_id}': Tool injection and prompt setting are deferred to TeamManager.")
+        return True
+

autobyteus/workflow/bootstrap_steps/base_workflow_bootstrap_step.py

@@ -0,0 +1,23 @@
+# file: autobyteus/autobyteus/workflow/bootstrap_steps/base_workflow_bootstrap_step.py
+import logging
+from abc import ABC, abstractmethod
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from autobyteus.workflow.context.workflow_context import WorkflowContext
+    from autobyteus.workflow.phases.workflow_phase_manager import WorkflowPhaseManager
+
+logger = logging.getLogger(__name__)
+
+class BaseWorkflowBootstrapStep(ABC):
+    """Abstract base class for individual steps in the workflow bootstrapping process."""
+
+    @abstractmethod
+    async def execute(self, context: 'WorkflowContext', phase_manager: 'WorkflowPhaseManager') -> bool:
+        """
+        Executes the bootstrap step.
+
+        Returns:
+            True if the step completed successfully, False otherwise.
+        """
+        raise NotImplementedError("Subclasses must implement the 'execute' method.")

autobyteus/workflow/bootstrap_steps/coordinator_initialization_step.py

@@ -0,0 +1,41 @@
+# file: autobyteus/autobyteus/workflow/bootstrap_steps/coordinator_initialization_step.py
+import logging
+from typing import TYPE_CHECKING
+
+from autobyteus.workflow.bootstrap_steps.base_workflow_bootstrap_step import BaseWorkflowBootstrapStep
+
+if TYPE_CHECKING:
+    from autobyteus.workflow.context.workflow_context import WorkflowContext
+    from autobyteus.workflow.phases.workflow_phase_manager import WorkflowPhaseManager
+
+logger = logging.getLogger(__name__)
+
+class CoordinatorInitializationStep(BaseWorkflowBootstrapStep):
+    """
+    Bootstrap step that eagerly instantiates and starts the coordinator agent
+    using the TeamManager. This ensures the coordinator is ready before the
+    workflow becomes idle.
+    """
+    async def execute(self, context: 'WorkflowContext', phase_manager: 'WorkflowPhaseManager') -> bool:
+        workflow_id = context.workflow_id
+        logger.info(f"Workflow '{workflow_id}': Executing CoordinatorInitializationStep.")
+        
+        try:
+            team_manager = context.team_manager
+            if not team_manager:
+                raise RuntimeError("TeamManager not found in workflow context. It should be created by the factory.")
+
+            coordinator_name = context.config.coordinator_node.name
+
+            # This call now ensures the coordinator agent is fully created and ready.
+            coordinator = await team_manager.ensure_coordinator_is_ready(coordinator_name)
+            
+            if not coordinator:
+                raise RuntimeError(f"TeamManager failed to return a ready coordinator agent for '{coordinator_name}'.")
+
+            logger.info(f"Workflow '{workflow_id}': Coordinator '{coordinator_name}' initialized and started via TeamManager.")
+            return True
+        
+        except Exception as e:
+            logger.error(f"Workflow '{workflow_id}': Failed to initialize coordinator agent: {e}", exc_info=True)
+            return False

autobyteus/workflow/bootstrap_steps/coordinator_prompt_preparation_step.py

@@ -0,0 +1,108 @@
+# file: autobyteus/autobyteus/workflow/bootstrap_steps/coordinator_prompt_preparation_step.py
+import logging
+from typing import TYPE_CHECKING, Dict, Set, List
+
+from autobyteus.workflow.bootstrap_steps.base_workflow_bootstrap_step import BaseWorkflowBootstrapStep
+from autobyteus.agent.context import AgentConfig
+from autobyteus.workflow.context.workflow_node_config import WorkflowNodeConfig
+from autobyteus.workflow.context.workflow_config import WorkflowConfig
+
+if TYPE_CHECKING:
+    from autobyteus.workflow.context.workflow_context import WorkflowContext
+    from autobyteus.workflow.phases.workflow_phase_manager import WorkflowPhaseManager
+
+logger = logging.getLogger(__name__)
+
+class CoordinatorPromptPreparationStep(BaseWorkflowBootstrapStep):
+    """
+    Bootstrap step to dynamically generate the coordinator's system prompt
+    based on the workflow's structure and store it in the workflow's state.
+    """
+    async def execute(self, context: 'WorkflowContext', phase_manager: 'WorkflowPhaseManager') -> bool:
+        workflow_id = context.workflow_id
+        logger.info(f"Workflow '{workflow_id}': Executing CoordinatorPromptPreparationStep.")
+        try:
+            coordinator_node = context.config.coordinator_node
+            member_nodes = {node for node in context.config.nodes if node != coordinator_node}
+
+            member_node_ids = self._generate_unique_node_ids(member_nodes)
+            dynamic_prompt = self._generate_prompt(context, member_node_ids)
+            
+            context.state.prepared_coordinator_prompt = dynamic_prompt
+
+            logger.info(f"Workflow '{workflow_id}': Coordinator prompt prepared successfully and stored in state.")
+            return True
+        except Exception as e:
+            logger.error(f"Workflow '{workflow_id}': Failed to prepare coordinator prompt: {e}", exc_info=True)
+            return False
+
+    def _generate_unique_node_ids(self, member_nodes: Set[WorkflowNodeConfig]) -> Dict[WorkflowNodeConfig, str]:
+        id_map: Dict[WorkflowNodeConfig, str] = {}
+        name_counts: Dict[str, int] = {}
+        sorted_nodes = sorted(list(member_nodes), key=lambda n: n.name)
+        for node in sorted_nodes:
+            base_name = node.name
+            count = name_counts.get(base_name, 0)
+            unique_id = f"{base_name}_{count + 1}" if base_name in name_counts else base_name
+            id_map[node] = unique_id
+            name_counts[base_name] = count + 1
+        return id_map
+
+    def _generate_prompt(self, context: 'WorkflowContext', member_node_ids: Dict[WorkflowNodeConfig, str]) -> str:
+        prompt_parts: List[str] = []
+
+        tools_section = (
+            "### Your Tools\n"
+            "To accomplish your goal, you have access to the following tools. You should use them as needed.\n"
+            "{{tools}}"
+        )
+
+        if member_node_ids:
+            role_and_goal = (
+                "You are the coordinator of a team of specialist agents and sub-workflows. Your primary goal is to "
+                "achieve the following objective by delegating tasks to your team members:\n"
+                f"### Goal\n{context.config.description}"
+            )
+            prompt_parts.append(role_and_goal)
+            
+            team_lines = []
+            for node, uid in member_node_ids.items():
+                node_def = node.node_definition
+                if node.is_subworkflow and isinstance(node_def, WorkflowConfig):
+                    # For sub-workflows, use its role and description
+                    role = node_def.role or "(Sub-Workflow)"
+                    team_lines.append(f"- **{uid}** (Role: {role}): {node_def.description}")
+                elif isinstance(node_def, AgentConfig):
+                    # For agents, use its role and description
+                    team_lines.append(f"- **{uid}** (Role: {node_def.role}): {node_def.description}")
+
+            team_manifest = "### Your Team\n" + "\n".join(team_lines)
+            prompt_parts.append(team_manifest)
+
+            rules_list: List[str] = []
+            for node, uid in member_node_ids.items():
+                if node.dependencies:
+                    dep_names = [member_node_ids.get(dep, dep.name) for dep in node.dependencies]
+                    rules_list.append(f"To use '{uid}', you must have already successfully used: {', '.join(f'`{name}`' for name in dep_names)}.")
+            
+            if rules_list:
+                rules_section = "### Execution Rules\n" + "\n".join(rules_list)
+                prompt_parts.append(rules_section)
+
+            prompt_parts.append(tools_section)
+                
+            final_instruction = "### Your Task\nAnalyze the user's request, formulate a plan, and use the `SendMessageTo` tool to delegate tasks to your team. Address team members by their unique ID as listed under 'Your Team'."
+            prompt_parts.append(final_instruction)
+        else:
+            role_and_goal = (
+                "You are working alone. Your primary goal is to achieve the following objective:\n"
+                f"### Goal\n{context.config.description}"
+            )
+            prompt_parts.append(role_and_goal)
+            prompt_parts.append("### Your Team\nYou are working alone on this task.")
+            prompt_parts.append(tools_section)
+            final_instruction = "### Your Task\nAnalyze the user's request, formulate a plan, and use your available tools to achieve the goal."
+            prompt_parts.append(final_instruction)
+
+        return "\n\n".join(prompt_parts)
+