autobyteus 1.2.0__py3-none-any.whl → 1.2.3__py3-none-any.whl

autobyteus/utils/file_utils.py

@@ -2,8 +2,11 @@
 
 import os
 import platform
+import tempfile
+from pathlib import Path
+from typing import Union
 
-def get_default_download_folder():
+def get_default_download_folder() -> str:
     system = platform.system()
     if system == "Windows":
         return os.path.join(os.path.expanduser("~"), "Downloads")
@@ -12,4 +15,56 @@ def get_default_download_folder():
     elif system == "Linux":
         return os.path.join(os.path.expanduser("~"), "Downloads")
     else:
-        return os.path.join(os.path.expanduser("~"), "Downloads")  # Fallback
+        return os.path.join(os.path.expanduser("~"), "Downloads")  # Fallback
+
+def resolve_safe_path(user_path: str, workspace_root: Union[str, Path]) -> Path:
+    """
+    Resolves a file path and ensures it is contained within allowed safe directories.
+    
+    Allowed directories:
+    1. The Agent's Workspace (workspace_root)
+    2. The User's Downloads directory
+    3. The System Temporary directory
+    
+    Args:
+        user_path: The relative or absolute path provided by the user/tool.
+        workspace_root: The root directory of the agent's workspace.
+        
+    Returns:
+        The resolved absolute Path object.
+        
+    Raises:
+        ValueError: If the path is outside the allowed directories.
+    """
+    workspace = Path(workspace_root).resolve()
+    downloads = Path(get_default_download_folder()).resolve()
+    temp_dir = Path(tempfile.gettempdir()).resolve()
+    
+    path_obj = Path(user_path)
+    
+    # If absolute, check directly. If relative, resolve against workspace.
+    if path_obj.is_absolute():
+        target = path_obj.resolve()
+    else:
+        target = (workspace / path_obj).resolve()
+    
+    # Allowed roots list
+    allowed_roots = [workspace, downloads, temp_dir]
+    
+    is_safe = False
+    for root in allowed_roots:
+        # Check if target is equal to or a subpath of root
+        try:
+            target.relative_to(root)
+            is_safe = True
+            break
+        except ValueError:
+            continue
+            
+    if not is_safe:
+        raise ValueError(
+            f"Security Violation: Path '{user_path}' is not within allowed directories "
+            f"(Workspace: {workspace}, Downloads: {downloads}, or Temp: {temp_dir})."
+        )
+        
+    return target

autobyteus/utils/gemini_helper.py

@@ -0,0 +1,56 @@
+import os
+import logging
+from dataclasses import dataclass
+from google import genai
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass(frozen=True)
+class GeminiRuntimeInfo:
+    runtime: str  # "vertex" or "api_key"
+    project: str | None
+    location: str | None
+
+def initialize_gemini_client_with_runtime() -> tuple[genai.Client, GeminiRuntimeInfo]:
+    """
+    Initializes the Google GenAI Client based on available environment variables.
+    Supports both Vertex AI (GCP) and AI Studio (API Key) modes.
+
+    Priority:
+    1. Vertex AI (requires VERTEX_AI_PROJECT and VERTEX_AI_LOCATION)
+    2. AI Studio (requires GEMINI_API_KEY)
+
+    Returns:
+        (client, runtime_info)
+
+    Raises:
+        ValueError: If neither configuration set is found.
+    """
+    # 1. Try Vertex AI Configuration
+    project = os.environ.get("VERTEX_AI_PROJECT")
+    location = os.environ.get("VERTEX_AI_LOCATION")
+
+    if project and location:
+        logger.info(
+            f"Initializing Gemini Client in Vertex AI mode (Project: {project}, Location: {location})"
+        )
+        client = genai.Client(vertexai=True, project=project, location=location)
+        return client, GeminiRuntimeInfo(runtime="vertex", project=project, location=location)
+
+    # 2. Try AI Studio Configuration (API Key)
+    api_key = os.environ.get("GEMINI_API_KEY")
+    if api_key:
+        logger.info("Initializing Gemini Client in AI Studio mode.")
+        client = genai.Client(api_key=api_key)
+        return client, GeminiRuntimeInfo(runtime="api_key", project=None, location=None)
+
+    # 3. Fallback / Error
+    error_msg = (
+        "Failed to initialize Gemini Client: Missing configuration. "
+        "Please set 'GEMINI_API_KEY' for AI Studio mode, OR set both "
+        "'VERTEX_AI_PROJECT' and 'VERTEX_AI_LOCATION' for Vertex AI mode."
+    )
+    logger.error(error_msg)
+    raise ValueError(error_msg)
+

autobyteus/utils/gemini_model_mapping.py

@@ -0,0 +1,71 @@
+"""Runtime-aware Gemini model name resolution (API key vs Vertex AI).
+
+Gemini uses different public names for some models between the Developer API
+(`gemini-*-*-preview` suffixes) and Vertex AI (no `-preview`). Keeping this
+logic separate lets clients stay focused on I/O while we centralize naming
+quirks.
+"""
+
+import logging
+
+logger = logging.getLogger(__name__)
+
+# Maps Developer API model names to their Vertex AI equivalents by modality.
+# As of Dec 18, 2025 the public LLM and image IDs are aligned across runtimes,
+# while some TTS variants still differ.
+_MODEL_RUNTIME_MAP = {
+    "tts": {
+        "gemini-2.5-flash-preview-tts": {
+            "vertex": "gemini-2.5-flash-tts",
+            "api_key": "gemini-2.5-flash-preview-tts",
+        },
+        "gemini-2.5-pro-preview-tts": {
+            "vertex": "gemini-2.5-pro-tts",
+            "api_key": "gemini-2.5-pro-preview-tts",
+        },
+    },
+    # For LLM & image the names are currently uniform across runtimes,
+    # but the structure is ready should Google introduce divergent aliases.
+    "llm": {
+        "gemini-3-pro-preview": {
+            "vertex": "gemini-3-pro-preview",
+            "api_key": "gemini-3-pro-preview",
+        },
+        "gemini-3-flash-preview": {
+            "vertex": "gemini-3-flash-preview",
+            "api_key": "gemini-3-flash-preview",
+        },
+    },
+    "image": {
+        "gemini-3-pro-image-preview": {
+            "vertex": "gemini-3-pro-image-preview",
+            "api_key": "gemini-3-pro-image-preview",
+        },
+        "gemini-2.5-flash-image": {
+            "vertex": "gemini-2.5-flash-image",
+            "api_key": "gemini-2.5-flash-image",
+        },
+    },
+}
+
+
+def resolve_model_for_runtime(model_value: str, modality: str, *, runtime: str | None = None) -> str:
+    """Return the correct model name for the active Gemini runtime.
+
+    Args:
+        model_value: The requested model name (usually from AudioModel.value).
+        modality: One of "tts", "llm", "image".
+        runtime: Explicit runtime identifier ("vertex" or "api_key").
+    """
+    if not runtime:
+        return model_value
+
+    modality_map = _MODEL_RUNTIME_MAP.get(modality, {})
+    runtime_map = modality_map.get(model_value)
+    if runtime_map and runtime in runtime_map:
+        mapped = runtime_map[runtime]
+        if mapped != model_value:
+            logger.info("Adjusting Gemini model for runtime '%s': '%s' -> '%s'", runtime, model_value, mapped)
+        return mapped
+
+    return model_value

autobyteus/utils/llm_output_formatter.py

@@ -0,0 +1,75 @@
+from typing import Any, Dict, List
+import dataclasses
+
+def format_to_clean_string(data: Any, indent: int = 0) -> str:
+    """
+    Formats complex data structures into a clean, human-readable string optimized for LLM consumption.
+    Avoids JSON syntax noise (braces, quotes) and YAML markers.
+    Supports Dicts, Lists, Dataclasses, and Pydantic models.
+    
+    Args:
+        data: The data to format.
+        indent: Current indentation level (spaces).
+        
+    Returns:
+        A formatted string representation of the data.
+    """
+    indent_str = " " * indent
+    
+    # Handle Dataclasses
+    if dataclasses.is_dataclass(data) and not isinstance(data, type):
+        data = dataclasses.asdict(data)
+    
+    # Handle Pydantic Models (v1: dict(), v2: model_dump())
+    elif hasattr(data, 'model_dump'):
+        data = data.model_dump()
+    elif hasattr(data, 'dict') and callable(getattr(data, 'dict')):
+        # Fallback for Pydantic V1 or similar
+        data = data.dict()
+
+    if isinstance(data, dict):
+        if not data:
+            return f"{indent_str}(empty dict)"
+        
+        lines = []
+        for key, value in data.items():
+            value_str = format_to_clean_string(value, indent + 2)
+            
+            if isinstance(value, (dict, list)) and value:
+                lines.append(f"{indent_str}{key}:\n{value_str}")
+            elif dataclasses.is_dataclass(value) or hasattr(value, 'model_dump') or hasattr(value, 'dict'):
+                 # Treat complex objects similarly to nested dicts
+                 lines.append(f"{indent_str}{key}:\n{value_str}")
+            elif isinstance(value, str) and '\n' in value:
+                # Multiline strings should also be on a new line for readability
+                lines.append(f"{indent_str}{key}:\n{value_str}")
+            else:
+                lines.append(f"{indent_str}{key}: {value_str.lstrip()}")
+        return "\n".join(lines)
+
+    elif isinstance(data, list):
+        if not data:
+            return f"{indent_str}(empty list)"
+        
+        lines = []
+        for item in data:
+            item_str = format_to_clean_string(item, indent + 2)
+            if isinstance(item, (dict, list)) or dataclasses.is_dataclass(item) or hasattr(item, 'model_dump'):
+                 lines.append(f"{indent_str}- \n{item_str}")
+            else:
+                lines.append(f"{indent_str}- {item_str.lstrip()}")
+        return "\n".join(lines)
+
+    elif isinstance(data, str):
+        lines = data.splitlines()
+        if not lines:
+            return f"{indent_str}\"\"" # Represent empty string explicitely or just empty? Let's use empty quotes for clarity if needed, or just nothing.
+            # Actually, user wants clean text. Empty string usually implies no content.
+            # Let's return "" if empty, but if it has content, indent it.
+            return ""
+        
+        formatted_lines = [f"{indent_str}{line}" for line in lines]
+        return "\n".join(formatted_lines)
+
+    else:
+        return f"{indent_str}{str(data)}"

autobyteus/utils/tool_call_format.py

@@ -0,0 +1,36 @@
+"""
+Helpers for resolving tool-call format selection.
+"""
+from __future__ import annotations
+
+import os
+
+
+ENV_TOOL_CALL_FORMAT = "AUTOBYTEUS_STREAM_PARSER"
+_VALID_FORMATS = {"xml", "json", "sentinel", "api_tool_call"}
+
+
+def resolve_tool_call_format() -> str:
+    """
+    Resolve the tool-call format from environment.
+
+    Returns one of: "xml", "json", "sentinel", "api_tool_call".
+    Defaults to "api_tool_call" when unset/invalid.
+    """
+    value = os.getenv(ENV_TOOL_CALL_FORMAT)
+    if not value:
+        return "api_tool_call"
+    value = value.strip().lower()
+    if value in _VALID_FORMATS:
+        return value
+    return "api_tool_call"
+
+
+def is_xml_tool_format() -> bool:
+    """Return True if tool-call format is forced to XML by environment."""
+    return resolve_tool_call_format() == "xml"
+
+
+def is_json_tool_format() -> bool:
+    """Return True if tool-call format is forced to JSON by environment."""
+    return resolve_tool_call_format() == "json"

autobyteus/workflow/agentic_workflow.py

@@ -5,7 +5,7 @@ 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
+from autobyteus.workflow.status.workflow_status import WorkflowStatus
 
 logger = logging.getLogger(__name__)
 
@@ -89,5 +89,5 @@ class AgenticWorkflow:
         """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
+    def get_current_status(self) -> WorkflowStatus: 
+        return self._runtime.context.state.current_status

autobyteus/workflow/bootstrap_steps/agent_tool_injection_step.py

@@ -10,7 +10,7 @@ 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
+    from autobyteus.workflow.status.workflow_status_manager import WorkflowStatusManager
 
 logger = logging.getLogger(__name__)
 
@@ -23,7 +23,7 @@ class AgentToolInjectionStep(BaseWorkflowBootstrapStep):
     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:
+    async def execute(self, context: 'WorkflowContext', status_manager: 'WorkflowStatusManager') -> 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

autobyteus/workflow/bootstrap_steps/base_workflow_bootstrap_step.py

@@ -5,7 +5,7 @@ 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
+    from autobyteus.workflow.status.workflow_status_manager import WorkflowStatusManager
 
 logger = logging.getLogger(__name__)
 
@@ -13,7 +13,7 @@ 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:
+    async def execute(self, context: 'WorkflowContext', status_manager: 'WorkflowStatusManager') -> bool:
         """
         Executes the bootstrap step.
 

autobyteus/workflow/bootstrap_steps/coordinator_initialization_step.py

@@ -6,7 +6,7 @@ from autobyteus.workflow.bootstrap_steps.base_workflow_bootstrap_step import Bas
 
 if TYPE_CHECKING:
     from autobyteus.workflow.context.workflow_context import WorkflowContext
-    from autobyteus.workflow.phases.workflow_phase_manager import WorkflowPhaseManager
+    from autobyteus.workflow.status.workflow_status_manager import WorkflowStatusManager
 
 logger = logging.getLogger(__name__)
 
@@ -16,7 +16,7 @@ class CoordinatorInitializationStep(BaseWorkflowBootstrapStep):
     using the TeamManager. This ensures the coordinator is ready before the
     workflow becomes idle.
     """
-    async def execute(self, context: 'WorkflowContext', phase_manager: 'WorkflowPhaseManager') -> bool:
+    async def execute(self, context: 'WorkflowContext', status_manager: 'WorkflowStatusManager') -> bool:
         workflow_id = context.workflow_id
         logger.info(f"Workflow '{workflow_id}': Executing CoordinatorInitializationStep.")
         

autobyteus/workflow/bootstrap_steps/coordinator_prompt_preparation_step.py

@@ -9,7 +9,7 @@ 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
+    from autobyteus.workflow.status.workflow_status_manager import WorkflowStatusManager
 
 logger = logging.getLogger(__name__)
 
@@ -18,7 +18,7 @@ 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:
+    async def execute(self, context: 'WorkflowContext', status_manager: 'WorkflowStatusManager') -> bool:
         workflow_id = context.workflow_id
         logger.info(f"Workflow '{workflow_id}': Executing CoordinatorPromptPreparationStep.")
         try:
@@ -51,11 +51,7 @@ class CoordinatorPromptPreparationStep(BaseWorkflowBootstrapStep):
     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 = (
@@ -89,9 +85,8 @@ class CoordinatorPromptPreparationStep(BaseWorkflowBootstrapStep):
                 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'."
+            final_instruction = "### Your Task\nAnalyze the user's request, formulate a plan, and use the `send_message_to` 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 = (
@@ -100,9 +95,7 @@ class CoordinatorPromptPreparationStep(BaseWorkflowBootstrapStep):
             )
             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)
-

autobyteus/workflow/bootstrap_steps/workflow_bootstrapper.py

@@ -11,7 +11,7 @@ from autobyteus.workflow.events.workflow_events import WorkflowReadyEvent
 
 if TYPE_CHECKING:
     from autobyteus.workflow.context.workflow_context import WorkflowContext
-    from autobyteus.workflow.phases.workflow_phase_manager import WorkflowPhaseManager
+    from autobyteus.workflow.status.workflow_status_manager import WorkflowStatusManager
 
 logger = logging.getLogger(__name__)
 
@@ -25,18 +25,18 @@ class WorkflowBootstrapper:
             CoordinatorInitializationStep(),
         ]
 
-    async def run(self, context: 'WorkflowContext', phase_manager: 'WorkflowPhaseManager') -> bool:
+    async def run(self, context: 'WorkflowContext', status_manager: 'WorkflowStatusManager') -> bool:
         workflow_id = context.workflow_id
-        await phase_manager.notify_bootstrapping_started()
+        await status_manager.notify_bootstrapping_started()
         logger.info(f"Workflow '{workflow_id}': Bootstrapper starting.")
 
         for step in self.bootstrap_steps:
             step_name = step.__class__.__name__
             logger.debug(f"Workflow '{workflow_id}': Executing bootstrap step: {step_name}")
-            if not await step.execute(context, phase_manager):
+            if not await step.execute(context, status_manager):
                 error_message = f"Bootstrap step {step_name} failed."
                 logger.error(f"Workflow '{workflow_id}': {error_message}")
-                await phase_manager.notify_error_occurred(error_message, f"Failed during bootstrap step '{step_name}'.")
+                await status_manager.notify_error_occurred(error_message, f"Failed during bootstrap step '{step_name}'.")
                 return False
         
         logger.info(f"Workflow '{workflow_id}': All bootstrap steps completed successfully.")
@@ -44,7 +44,7 @@ class WorkflowBootstrapper:
             await context.state.input_event_queues.enqueue_internal_system_event(WorkflowReadyEvent())
         else:
             logger.critical(f"Workflow '{workflow_id}': Bootstrap succeeded but queues not available.")
-            await phase_manager.notify_error_occurred("Queues unavailable after bootstrap.", "")
+            await status_manager.notify_error_occurred("Queues unavailable after bootstrap.", "")
             return False
             
         return True

autobyteus/workflow/bootstrap_steps/workflow_runtime_queue_initialization_step.py

@@ -7,13 +7,13 @@ from autobyteus.workflow.events.workflow_input_event_queue_manager import Workfl
 
 if TYPE_CHECKING:
     from autobyteus.workflow.context.workflow_context import WorkflowContext
-    from autobyteus.workflow.phases.workflow_phase_manager import WorkflowPhaseManager
+    from autobyteus.workflow.status.workflow_status_manager import WorkflowStatusManager
 
 logger = logging.getLogger(__name__)
 
 class WorkflowRuntimeQueueInitializationStep(BaseWorkflowBootstrapStep):
     """Bootstrap step for initializing the workflow's runtime event queues."""
-    async def execute(self, context: 'WorkflowContext', phase_manager: 'WorkflowPhaseManager') -> bool:
+    async def execute(self, context: 'WorkflowContext', status_manager: 'WorkflowStatusManager') -> bool:
         workflow_id = context.workflow_id
         logger.info(f"Workflow '{workflow_id}': Executing WorkflowRuntimeQueueInitializationStep.")
         try:

autobyteus/workflow/context/workflow_context.py

@@ -6,7 +6,7 @@ if TYPE_CHECKING:
     from autobyteus.workflow.context.workflow_config import WorkflowConfig
     from autobyteus.workflow.context.workflow_runtime_state import WorkflowRuntimeState
     from autobyteus.agent.agent import Agent
-    from autobyteus.workflow.phases.workflow_phase_manager import WorkflowPhaseManager
+    from autobyteus.workflow.status.workflow_status_manager import WorkflowStatusManager
     from autobyteus.workflow.context.team_manager import TeamManager
     from autobyteus.workflow.streaming.agent_event_multiplexer import AgentEventMultiplexer
     from autobyteus.agent.context import AgentConfig
@@ -49,8 +49,8 @@ class WorkflowContext:
         return None
 
     @property
-    def phase_manager(self) -> Optional['WorkflowPhaseManager']:
-        return self.state.phase_manager_ref
+    def status_manager(self) -> Optional['WorkflowStatusManager']:
+        return self.state.status_manager_ref
 
     @property
     def team_manager(self) -> Optional['TeamManager']:

autobyteus/workflow/context/workflow_runtime_state.py

@@ -2,13 +2,13 @@
 import logging
 from typing import List, Optional, TYPE_CHECKING, Dict
 
-from autobyteus.workflow.phases.workflow_operational_phase import WorkflowOperationalPhase
+from autobyteus.workflow.status.workflow_status import WorkflowStatus
 from autobyteus.agent.context import AgentConfig
 
 if TYPE_CHECKING:
     from autobyteus.agent.agent import Agent
     from autobyteus.workflow.events.workflow_input_event_queue_manager import WorkflowInputEventQueueManager
-    from autobyteus.workflow.phases.workflow_phase_manager import WorkflowPhaseManager
+    from autobyteus.workflow.status.workflow_status_manager import WorkflowStatusManager
     from autobyteus.workflow.context.workflow_node_config import WorkflowNodeConfig
     from autobyteus.workflow.context.team_manager import TeamManager
     from autobyteus.workflow.streaming.agent_event_multiplexer import AgentEventMultiplexer
@@ -22,7 +22,7 @@ class WorkflowRuntimeState:
             raise ValueError("WorkflowRuntimeState requires a non-empty string 'workflow_id'.")
 
         self.workflow_id: str = workflow_id
-        self.current_phase: WorkflowOperationalPhase = WorkflowOperationalPhase.UNINITIALIZED
+        self.current_status: WorkflowStatus = WorkflowStatus.UNINITIALIZED
         
         # State populated by bootstrap steps
         self.prepared_coordinator_prompt: Optional[str] = None
@@ -34,7 +34,7 @@ class WorkflowRuntimeState:
 
         # Runtime components and references
         self.input_event_queues: Optional['WorkflowInputEventQueueManager'] = None
-        self.phase_manager_ref: Optional['WorkflowPhaseManager'] = None
+        self.status_manager_ref: Optional['WorkflowStatusManager'] = None
         self.multiplexer_ref: Optional['AgentEventMultiplexer'] = None
 
         logger.info(f"WorkflowRuntimeState initialized for workflow_id '{self.workflow_id}'.")
@@ -48,6 +48,6 @@ class WorkflowRuntimeState:
     def __repr__(self) -> str:
         agents_count = len(self.team_manager.get_all_agents()) if self.team_manager else 0
         coordinator_set = self.team_manager.coordinator_agent is not None if self.team_manager else False
-        return (f"<WorkflowRuntimeState id='{self.workflow_id}', phase='{self.current_phase.value}', "
+        return (f"<WorkflowRuntimeState id='{self.workflow_id}', status='{self.current_status.value}', "
                 f"agents_count={agents_count}, coordinator_set={coordinator_set}, "
                 f"team_manager_set={self.team_manager is not None}>")

autobyteus/workflow/events/workflow_event_dispatcher.py

@@ -8,7 +8,7 @@ from autobyteus.workflow.events.workflow_events import BaseWorkflowEvent, Workfl
 if TYPE_CHECKING:
     from autobyteus.workflow.context.workflow_context import WorkflowContext
     from autobyteus.workflow.handlers.workflow_event_handler_registry import WorkflowEventHandlerRegistry
-    from autobyteus.workflow.phases.workflow_phase_manager import WorkflowPhaseManager
+    from autobyteus.workflow.status.workflow_status_manager import WorkflowStatusManager
 
 logger = logging.getLogger(__name__)
 
@@ -17,9 +17,9 @@ class WorkflowEventDispatcher:
 
     def __init__(self,
                  event_handler_registry: 'WorkflowEventHandlerRegistry',
-                 phase_manager: 'WorkflowPhaseManager'):
+                 status_manager: 'WorkflowStatusManager'):
         self.registry = event_handler_registry
-        self.phase_manager = phase_manager
+        self.status_manager = status_manager
 
     async def dispatch(self, event: BaseWorkflowEvent, context: 'WorkflowContext'):
         handler = self.registry.get_handler(type(event))
@@ -32,8 +32,8 @@ class WorkflowEventDispatcher:
         try:
             await handler.handle(event, context)
             if isinstance(event, WorkflowReadyEvent):
-                await self.phase_manager.notify_initialization_complete()
+                await self.status_manager.notify_initialization_complete()
         except Exception as e:
             error_msg = f"Error handling '{type(event).__name__}' in workflow '{workflow_id}': {e}"
             logger.error(error_msg, exc_info=True)
-            await self.phase_manager.notify_error_occurred(error_msg, traceback.format_exc())
+            await self.status_manager.notify_error_occurred(error_msg, traceback.format_exc())

autobyteus/workflow/handlers/lifecycle_workflow_event_handler.py

@@ -14,14 +14,14 @@ class LifecycleWorkflowEventHandler(BaseWorkflowEventHandler):
     """Logs various lifecycle events for a workflow."""
     async def handle(self, event: BaseWorkflowEvent, context: 'WorkflowContext') -> None:
         workflow_id = context.workflow_id
-        current_phase = context.state.current_phase.value
+        current_status = context.state.current_status.value
 
         if isinstance(event, WorkflowReadyEvent):
-            logger.info(f"Workflow '{workflow_id}' Logged WorkflowReadyEvent. Current phase: {current_phase}")
+            logger.info(f"Workflow '{workflow_id}' Logged WorkflowReadyEvent. Current status: {current_status}")
         elif isinstance(event, WorkflowErrorEvent):
             logger.error(
                 f"Workflow '{workflow_id}' Logged WorkflowErrorEvent: {event.error_message}. "
-                f"Details: {event.exception_details}. Current phase: {current_phase}"
+                f"Details: {event.exception_details}. Current status: {current_status}"
             )
         else:
             logger.warning(f"LifecycleWorkflowEventHandler received unhandled event type: {type(event).__name__}")

autobyteus/workflow/handlers/process_user_message_event_handler.py

@@ -15,13 +15,13 @@ logger = logging.getLogger(__name__)
 class ProcessUserMessageEventHandler(BaseWorkflowEventHandler):
     """Handles user messages by routing them to the specified target agent or sub-workflow."""
     async def handle(self, event: ProcessUserMessageEvent, context: 'WorkflowContext') -> None:
-        await context.phase_manager.notify_processing_started()
+        await context.status_manager.notify_processing_started()
         
         team_manager = context.team_manager
         if not team_manager:
             msg = f"Workflow '{context.workflow_id}': TeamManager not found. Cannot route message."
             logger.error(msg)
-            await context.phase_manager.notify_error_occurred(msg, "TeamManager is not initialized.")
+            await context.status_manager.notify_error_occurred(msg, "TeamManager is not initialized.")
             return
 
         try:
@@ -29,7 +29,7 @@ class ProcessUserMessageEventHandler(BaseWorkflowEventHandler):
         except Exception as e:
             msg = f"Workflow '{context.workflow_id}': Node '{event.target_agent_name}' not found or failed to start. Cannot route message. Error: {e}"
             logger.error(msg, exc_info=True)
-            await context.phase_manager.notify_error_occurred(msg, f"Node '{event.target_agent_name}' not found or failed to start.")
+            await context.status_manager.notify_error_occurred(msg, f"Node '{event.target_agent_name}' not found or failed to start.")
             return
 
         if isinstance(target_node, Agent):
@@ -41,6 +41,6 @@ class ProcessUserMessageEventHandler(BaseWorkflowEventHandler):
         else:
             msg = f"Target node '{event.target_agent_name}' is of an unsupported type: {type(target_node).__name__}"
             logger.error(f"Workflow '{context.workflow_id}': {msg}")
-            await context.phase_manager.notify_error_occurred(msg, "")
+            await context.status_manager.notify_error_occurred(msg, "")
 
-        await context.phase_manager.notify_processing_complete_and_idle()
+        await context.status_manager.notify_processing_complete_and_idle()