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

examples/workflow/run_workflow_with_tui.py

@@ -0,0 +1,153 @@
+# file: autobyteus/examples/workflow/run_workflow_with_tui.py
+"""
+This example script demonstrates how to run an AgenticWorkflow with the
+new Textual-based user interface.
+"""
+import asyncio
+import logging
+import argparse
+from pathlib import Path
+import sys
+import os
+
+# --- Boilerplate to make the script runnable from the project root ---
+SCRIPT_DIR = Path(__file__).resolve().parent.parent
+PACKAGE_ROOT = SCRIPT_DIR.parent
+if str(PACKAGE_ROOT) not in sys.path:
+    sys.path.insert(0, str(PACKAGE_ROOT))
+
+# Load environment variables from .env file
+try:
+    from dotenv import load_dotenv
+    load_dotenv(PACKAGE_ROOT / ".env")
+except ImportError:
+    pass
+
+# --- Imports for the Workflow TUI Example ---
+try:
+    from autobyteus.agent.context import AgentConfig
+    from autobyteus.llm.models import LLMModel
+    from autobyteus.llm.llm_factory import default_llm_factory, LLMFactory
+    from autobyteus.workflow.workflow_builder import WorkflowBuilder
+    from autobyteus.cli.workflow_tui.app import WorkflowApp
+except ImportError as e:
+    print(f"Error importing autobyteus components: {e}", file=sys.stderr)
+    sys.exit(1)
+
+# --- Logging Setup ---
+# It's crucial to log to a file so that stdout/stderr are free for Textual.
+def setup_file_logging() -> Path:
+    """
+    Sets up file-based logging and returns the path to the log file.
+    """
+    log_dir = PACKAGE_ROOT / "logs"
+    log_dir.mkdir(exist_ok=True)
+    log_file_path = log_dir / "workflow_tui_app.log"
+    
+    logging.basicConfig(
+        level=logging.INFO,
+        format="%(asctime)s [%(levelname)s] %(name)s: %(message)s",
+        filename=log_file_path,
+        filemode="w",
+    )
+    # Silence the noisy asyncio logger in the file log
+    logging.getLogger("asyncio").setLevel(logging.WARNING)
+    logging.getLogger("textual").setLevel(logging.WARNING)
+    
+    return log_file_path
+
+def create_demo_workflow(model_name: str):
+    """Creates a simple two-agent workflow for the TUI demonstration."""
+    # The factory will handle API key checks based on the selected model's provider.
+
+    # Validate model
+    try:
+        _ = LLMModel[model_name]
+    except KeyError:
+        logging.critical(f"LLM Model '{model_name}' is not valid. Use --help-models to see available models.")
+        print(f"\nCRITICAL ERROR: LLM Model '{model_name}' is not valid. Use --help-models to see available models.\nCheck log file for details.")
+        sys.exit(1)
+
+    # Coordinator Agent Config - Gets its own LLM instance
+    coordinator_config = AgentConfig(
+        name="Coordinator",
+        role="Project Manager",
+        description="Delegates tasks to the team to fulfill the user's request.",
+        llm_instance=default_llm_factory.create_llm(model_identifier=model_name),
+        system_prompt=(
+            "You are a project manager. Your job is to understand the user's request and delegate tasks to your team. "
+            "The workflow will provide you with a team manifest. Use your tools to communicate with your team.\n\n"
+            "Here are your available tools:\n"
+            "{{tools}}"
+        )
+    )
+
+    # Specialist Agent Config (FactChecker) - Gets its own LLM instance
+    fact_checker_config = AgentConfig(
+        name="FactChecker",
+        role="Specialist",
+        description="An agent with a limited, internal knowledge base for answering direct factual questions.",
+        llm_instance=default_llm_factory.create_llm(model_identifier=model_name),
+        system_prompt=(
+            "You are a fact-checking bot. You have the following knowledge:\n"
+            "- The capital of France is Paris.\n"
+            "- The tallest mountain on Earth is Mount Everest.\n"
+            "If asked something you don't know, say 'I do not have information on that topic.'\n\n"
+            "Here is the manifest of tools available to you:\n"
+            "{{tools}}"
+        )
+    )
+
+    # Build the workflow
+    workflow = (
+        WorkflowBuilder(
+            name="TUIDemoWorkflow",
+            description="A simple two-agent workflow for demonstrating the TUI."
+        )
+        .set_coordinator(coordinator_config)
+        .add_agent_node(fact_checker_config, dependencies=[])
+        .build()
+    )
+    return workflow
+
+async def main(args: argparse.Namespace, log_file: Path):
+    """Main async function to create the workflow and run the TUI app."""
+    print("Setting up workflow...")
+    print(f"--> Logs will be written to: {log_file.resolve()}")
+    try:
+        workflow = create_demo_workflow(model_name=args.llm_model)
+        app = WorkflowApp(workflow=workflow)
+        await app.run_async()
+    except Exception as e:
+        logging.critical(f"Failed to create or run workflow TUI: {e}", exc_info=True)
+        print(f"\nCRITICAL ERROR: {e}\nCheck log file for details: {log_file.resolve()}")
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Run an AgenticWorkflow with a Textual TUI.")
+    parser.add_argument("--llm-model", type=str, default="kimi-latest", help="The LLM model to use for the agents.")
+    parser.add_argument("--help-models", action="store_true", help="Display available LLM models and exit.")
+    
+    if "--help-models" in sys.argv:
+        try:
+            LLMFactory.ensure_initialized()
+            print("Available LLM Models (you can use either name or value with --llm-model):")
+            all_models = sorted(list(LLMModel), key=lambda m: m.name)
+            if not all_models:
+                print("  No models found.")
+            for model in all_models:
+                print(f"  - Name: {model.name:<35} Value: {model.value}")
+        except Exception as e:
+            print(f"Error listing models: {e}")
+        sys.exit(0)
+
+    parsed_args = parser.parse_args()
+
+    log_file_path = setup_file_logging()
+    try:
+        asyncio.run(main(parsed_args, log_file_path))
+    except KeyboardInterrupt:
+        print("\nExiting application.")
+    except Exception as e:
+        # This catches errors during asyncio.run, which might not be logged otherwise
+        logging.critical(f"Top-level application error: {e}", exc_info=True)
+        print(f"\nUNHANDLED ERROR: {e}\nCheck log file for details: {log_file_path.resolve()}")

autobyteus/agent/context/agent_phase_manager.py

@@ -1,264 +0,0 @@
-# file: autobyteus/autobyteus/agent/context/agent_phase_manager.py
-import asyncio
-import logging
-from typing import TYPE_CHECKING, Optional, Dict, Any
-
-from autobyteus.agent.phases import AgentOperationalPhase, phase_transition
-
-if TYPE_CHECKING:
-    from autobyteus.agent.context.agent_context import AgentContext
-    from autobyteus.agent.tool_invocation import ToolInvocation
-    from autobyteus.agent.events.notifiers import AgentExternalEventNotifier
-
-
-logger = logging.getLogger(__name__)
-
-class AgentPhaseManager:
-    """
-    Manages the operational phase of an agent, uses an AgentExternalEventNotifier
-    to signal phase changes externally, and executes phase transition hooks.
-    """
-    def __init__(self, context: 'AgentContext', notifier: 'AgentExternalEventNotifier'):
-        self.context: 'AgentContext' = context
-        self.notifier: 'AgentExternalEventNotifier' = notifier
-
-        self.context.current_phase = AgentOperationalPhase.UNINITIALIZED
-        
-        logger.debug(f"AgentPhaseManager initialized for agent_id '{self.context.agent_id}'. "
-                     f"Initial phase: {self.context.current_phase.value}. Uses provided notifier.")
-
-    async def _execute_hooks(self, old_phase: AgentOperationalPhase, new_phase: AgentOperationalPhase):
-        """Asynchronously executes hooks that match the given phase transition."""
-        hooks_to_run = [
-            hook for hook in self.context.config.phase_hooks
-            if hook.source_phase == old_phase and hook.target_phase == new_phase
-        ]
-
-        if not hooks_to_run:
-            return
-
-        hook_names = [hook.__class__.__name__ for hook in hooks_to_run]
-        logger.info(f"Agent '{self.context.agent_id}': Executing {len(hooks_to_run)} hooks for transition "
-                    f"'{old_phase.value}' -> '{new_phase.value}': {hook_names}")
-        
-        for hook in hooks_to_run:
-            try:
-                await hook.execute(self.context)
-                logger.debug(f"Agent '{self.context.agent_id}': Hook '{hook.__class__.__name__}' executed successfully.")
-            except Exception as e:
-                logger.error(f"Agent '{self.context.agent_id}': Error executing phase transition hook "
-                             f"'{hook.__class__.__name__}' for '{old_phase.value}' -> '{new_phase.value}': {e}",
-                             exc_info=True)
-                # We log the error but do not halt the agent's phase transition.
-
-    async def _transition_phase(self, new_phase: AgentOperationalPhase,
-                                notify_method_name: str,
-                                additional_data: Optional[Dict[str, Any]] = None):
-        """
-        Private async helper to change the agent's phase, execute hooks, and then
-        call the appropriate notifier method. Hooks are now awaited.
-        """
-        if not isinstance(new_phase, AgentOperationalPhase):
-            logger.error(f"AgentPhaseManager for '{self.context.agent_id}' received invalid type for new_phase: {type(new_phase)}. Must be AgentOperationalPhase.")
-            return
-
-        old_phase = self.context.current_phase
-        
-        if old_phase == new_phase:
-            logger.debug(f"AgentPhaseManager for '{self.context.agent_id}': already in phase {new_phase.value}. No transition.")
-            return
-
-        logger.info(f"Agent '{self.context.agent_id}' phase transitioning from {old_phase.value} to {new_phase.value}.")
-        self.context.current_phase = new_phase
-
-        # Execute and wait for hooks to complete *before* notifying externally.
-        await self._execute_hooks(old_phase, new_phase)
-
-        notifier_method = getattr(self.notifier, notify_method_name, None)
-        if notifier_method and callable(notifier_method):
-            notify_args = {"old_phase": old_phase}
-            if additional_data:
-                notify_args.update(additional_data)
-            
-            notifier_method(**notify_args)
-        else: 
-            logger.error(f"AgentPhaseManager for '{self.context.agent_id}': Notifier method '{notify_method_name}' not found or not callable on {type(self.notifier).__name__}.")
-
-    @phase_transition(
-        source_phases=[AgentOperationalPhase.SHUTDOWN_COMPLETE, AgentOperationalPhase.ERROR],
-        target_phase=AgentOperationalPhase.UNINITIALIZED,
-        description="Triggered when the agent runtime is started or restarted after being in a terminal state."
-    )
-    async def notify_runtime_starting_and_uninitialized(self) -> None:
-        if self.context.current_phase == AgentOperationalPhase.UNINITIALIZED:
-            await self._transition_phase(AgentOperationalPhase.UNINITIALIZED, "notify_phase_uninitialized_entered")
-        elif self.context.current_phase.is_terminal():
-             await self._transition_phase(AgentOperationalPhase.UNINITIALIZED, "notify_phase_uninitialized_entered")
-        else:
-             logger.warning(f"Agent '{self.context.agent_id}' notify_runtime_starting_and_uninitialized called in unexpected phase: {self.context.current_phase.value}")
-
-    @phase_transition(
-        source_phases=[AgentOperationalPhase.UNINITIALIZED],
-        target_phase=AgentOperationalPhase.BOOTSTRAPPING,
-        description="Occurs when the agent's internal bootstrapping process begins."
-    )
-    async def notify_bootstrapping_started(self) -> None:
-        await self._transition_phase(AgentOperationalPhase.BOOTSTRAPPING, "notify_phase_bootstrapping_started")
-
-    @phase_transition(
-        source_phases=[AgentOperationalPhase.BOOTSTRAPPING],
-        target_phase=AgentOperationalPhase.IDLE,
-        description="Occurs when the agent successfully completes bootstrapping and is ready for input."
-    )
-    async def notify_initialization_complete(self) -> None:
-        if self.context.current_phase.is_initializing() or self.context.current_phase == AgentOperationalPhase.UNINITIALIZED:
-            # This will now be a BOOTSTRAPPING -> IDLE transition
-            await self._transition_phase(AgentOperationalPhase.IDLE, "notify_phase_idle_entered")
-        else:
-            logger.warning(f"Agent '{self.context.agent_id}' notify_initialization_complete called in unexpected phase: {self.context.current_phase.value}")
-
-    @phase_transition(
-        source_phases=[
-            AgentOperationalPhase.IDLE, AgentOperationalPhase.ANALYZING_LLM_RESPONSE,
-            AgentOperationalPhase.PROCESSING_TOOL_RESULT, AgentOperationalPhase.EXECUTING_TOOL,
-            AgentOperationalPhase.TOOL_DENIED
-        ],
-        target_phase=AgentOperationalPhase.PROCESSING_USER_INPUT,
-        description="Fires when the agent begins processing a new user message or inter-agent message."
-    )
-    async def notify_processing_input_started(self, trigger_info: Optional[str] = None) -> None:
-        if self.context.current_phase in [AgentOperationalPhase.IDLE, AgentOperationalPhase.ANALYZING_LLM_RESPONSE, AgentOperationalPhase.PROCESSING_TOOL_RESULT, AgentOperationalPhase.EXECUTING_TOOL, AgentOperationalPhase.TOOL_DENIED]:
-            data = {"trigger_info": trigger_info} if trigger_info else {}
-            await self._transition_phase(AgentOperationalPhase.PROCESSING_USER_INPUT, "notify_phase_processing_user_input_started", additional_data=data)
-        elif self.context.current_phase == AgentOperationalPhase.PROCESSING_USER_INPUT:
-             logger.debug(f"Agent '{self.context.agent_id}' already in PROCESSING_USER_INPUT phase.")
-        else:
-             logger.warning(f"Agent '{self.context.agent_id}' notify_processing_input_started called in unexpected phase: {self.context.current_phase.value}")
-
-    @phase_transition(
-        source_phases=[AgentOperationalPhase.PROCESSING_USER_INPUT, AgentOperationalPhase.PROCESSING_TOOL_RESULT],
-        target_phase=AgentOperationalPhase.AWAITING_LLM_RESPONSE,
-        description="Occurs just before the agent makes a call to the LLM."
-    )
-    async def notify_awaiting_llm_response(self) -> None:
-        await self._transition_phase(AgentOperationalPhase.AWAITING_LLM_RESPONSE, "notify_phase_awaiting_llm_response_started")
-
-    @phase_transition(
-        source_phases=[AgentOperationalPhase.AWAITING_LLM_RESPONSE],
-        target_phase=AgentOperationalPhase.ANALYZING_LLM_RESPONSE,
-        description="Occurs after the agent has received a complete response from the LLM and begins to analyze it."
-    )
-    async def notify_analyzing_llm_response(self) -> None:
-        await self._transition_phase(AgentOperationalPhase.ANALYZING_LLM_RESPONSE, "notify_phase_analyzing_llm_response_started")
-
-    @phase_transition(
-        source_phases=[AgentOperationalPhase.ANALYZING_LLM_RESPONSE],
-        target_phase=AgentOperationalPhase.AWAITING_TOOL_APPROVAL,
-        description="Occurs if the agent proposes a tool use that requires manual user approval."
-    )
-    async def notify_tool_execution_pending_approval(self, tool_invocation: 'ToolInvocation') -> None:
-        await self._transition_phase(AgentOperationalPhase.AWAITING_TOOL_APPROVAL, "notify_phase_awaiting_tool_approval_started")
-
-    @phase_transition(
-        source_phases=[AgentOperationalPhase.AWAITING_TOOL_APPROVAL],
-        target_phase=AgentOperationalPhase.EXECUTING_TOOL,
-        description="Occurs after a pending tool use has been approved and is about to be executed."
-    )
-    async def notify_tool_execution_resumed_after_approval(self, approved: bool, tool_name: Optional[str]) -> None:
-        if approved and tool_name:
-            await self._transition_phase(AgentOperationalPhase.EXECUTING_TOOL, "notify_phase_executing_tool_started", additional_data={"tool_name": tool_name})
-        else:
-            logger.info(f"Agent '{self.context.agent_id}' tool execution denied for '{tool_name}'. Transitioning to allow LLM to process denial.")
-            await self.notify_tool_denied(tool_name)
-
-    @phase_transition(
-        source_phases=[AgentOperationalPhase.AWAITING_TOOL_APPROVAL],
-        target_phase=AgentOperationalPhase.TOOL_DENIED,
-        description="Occurs after a pending tool use has been denied by the user."
-    )
-    async def notify_tool_denied(self, tool_name: Optional[str]) -> None:
-        """Notifies that a tool execution has been denied."""
-        await self._transition_phase(
-            AgentOperationalPhase.TOOL_DENIED,
-            "notify_phase_tool_denied_started",
-            additional_data={"tool_name": tool_name, "denial_for_tool": tool_name}
-        )
-
-    @phase_transition(
-        source_phases=[AgentOperationalPhase.ANALYZING_LLM_RESPONSE],
-        target_phase=AgentOperationalPhase.EXECUTING_TOOL,
-        description="Occurs when an agent with auto-approval executes a tool."
-    )
-    async def notify_tool_execution_started(self, tool_name: str) -> None:
-        await self._transition_phase(AgentOperationalPhase.EXECUTING_TOOL, "notify_phase_executing_tool_started", additional_data={"tool_name": tool_name})
-
-    @phase_transition(
-        source_phases=[AgentOperationalPhase.EXECUTING_TOOL],
-        target_phase=AgentOperationalPhase.PROCESSING_TOOL_RESULT,
-        description="Fires after a tool has finished executing and the agent begins processing its result."
-    )
-    async def notify_processing_tool_result(self, tool_name: str) -> None:
-        await self._transition_phase(AgentOperationalPhase.PROCESSING_TOOL_RESULT, "notify_phase_processing_tool_result_started", additional_data={"tool_name": tool_name})
-
-    @phase_transition(
-        source_phases=[
-            AgentOperationalPhase.PROCESSING_USER_INPUT, AgentOperationalPhase.ANALYZING_LLM_RESPONSE,
-            AgentOperationalPhase.PROCESSING_TOOL_RESULT
-        ],
-        target_phase=AgentOperationalPhase.IDLE,
-        description="Occurs when an agent completes a processing cycle and is waiting for new input."
-    )
-    async def notify_processing_complete_and_idle(self) -> None:
-        if not self.context.current_phase.is_terminal() and self.context.current_phase != AgentOperationalPhase.IDLE:
-            await self._transition_phase(AgentOperationalPhase.IDLE, "notify_phase_idle_entered")
-        elif self.context.current_phase == AgentOperationalPhase.IDLE:
-            logger.debug(f"Agent '{self.context.agent_id}' processing complete, already IDLE.")
-        else:
-            logger.warning(f"Agent '{self.context.agent_id}' notify_processing_complete_and_idle called in unexpected phase: {self.context.current_phase.value}")
-
-    @phase_transition(
-        source_phases=[
-            AgentOperationalPhase.UNINITIALIZED, AgentOperationalPhase.BOOTSTRAPPING, AgentOperationalPhase.IDLE,
-            AgentOperationalPhase.PROCESSING_USER_INPUT, AgentOperationalPhase.AWAITING_LLM_RESPONSE,
-            AgentOperationalPhase.ANALYZING_LLM_RESPONSE, AgentOperationalPhase.AWAITING_TOOL_APPROVAL,
-            AgentOperationalPhase.TOOL_DENIED, AgentOperationalPhase.EXECUTING_TOOL,
-            AgentOperationalPhase.PROCESSING_TOOL_RESULT, AgentOperationalPhase.SHUTTING_DOWN
-        ],
-        target_phase=AgentOperationalPhase.ERROR,
-        description="A catch-all transition that can occur from any non-terminal state if an unrecoverable error happens."
-    )
-    async def notify_error_occurred(self, error_message: str, error_details: Optional[str] = None) -> None:
-        if self.context.current_phase != AgentOperationalPhase.ERROR:
-            data = {"error_message": error_message, "error_details": error_details}
-            await self._transition_phase(AgentOperationalPhase.ERROR, "notify_phase_error_entered", additional_data=data)
-        else:
-            logger.debug(f"Agent '{self.context.agent_id}' already in ERROR phase when another error notified: {error_message}")
-
-    @phase_transition(
-        source_phases=[
-            AgentOperationalPhase.UNINITIALIZED, AgentOperationalPhase.BOOTSTRAPPING, AgentOperationalPhase.IDLE,
-            AgentOperationalPhase.PROCESSING_USER_INPUT, AgentOperationalPhase.AWAITING_LLM_RESPONSE,
-            AgentOperationalPhase.ANALYZING_LLM_RESPONSE, AgentOperationalPhase.AWAITING_TOOL_APPROVAL,
-            AgentOperationalPhase.TOOL_DENIED, AgentOperationalPhase.EXECUTING_TOOL,
-            AgentOperationalPhase.PROCESSING_TOOL_RESULT
-        ],
-        target_phase=AgentOperationalPhase.SHUTTING_DOWN,
-        description="Fires when the agent begins its graceful shutdown sequence."
-    )
-    async def notify_shutdown_initiated(self) -> None:
-        if not self.context.current_phase.is_terminal():
-             await self._transition_phase(AgentOperationalPhase.SHUTTING_DOWN, "notify_phase_shutting_down_started")
-        else:
-            logger.debug(f"Agent '{self.context.agent_id}' shutdown initiated but already in a terminal phase: {self.context.current_phase.value}")
-
-    @phase_transition(
-        source_phases=[AgentOperationalPhase.SHUTTING_DOWN],
-        target_phase=AgentOperationalPhase.SHUTDOWN_COMPLETE,
-        description="The final transition when the agent has successfully shut down and released its resources."
-    )
-    async def notify_final_shutdown_complete(self) -> None:
-        final_phase = AgentOperationalPhase.ERROR if self.context.current_phase == AgentOperationalPhase.ERROR else AgentOperationalPhase.SHUTDOWN_COMPLETE
-        if final_phase == AgentOperationalPhase.ERROR:
-            await self._transition_phase(AgentOperationalPhase.ERROR, "notify_phase_error_entered", additional_data={"error_message": "Shutdown completed with agent in error state."})
-        else:
-            await self._transition_phase(AgentOperationalPhase.SHUTDOWN_COMPLETE, "notify_phase_shutdown_completed")

autobyteus/agent/context/phases.py

@@ -1,49 +0,0 @@
-# file: autobyteus/autobyteus/agent/context/phases.py
-from enum import Enum
-
-class AgentOperationalPhase(str, Enum):
-    """
-    Defines the fine-grained operational phases of an agent.
-    This is the single source of truth for an agent's current state of operation.
-    """
-    UNINITIALIZED = "uninitialized"            # Agent object created, but runtime not started or fully set up.
-    BOOTSTRAPPING = "bootstrapping"            # Agent is running its internal initialization/bootstrap sequence.
-    IDLE = "idle"                              # Fully initialized and ready for new input.
-    
-    PROCESSING_USER_INPUT = "processing_user_input"     # Actively processing a user message, typically preparing for an LLM call.
-    AWAITING_LLM_RESPONSE = "awaiting_llm_response"     # Sent a request to LLM, waiting for the full response or stream.
-    ANALYZING_LLM_RESPONSE = "analyzing_llm_response"   # Received LLM response, analyzing it for next actions (e.g., tool use, direct reply).
-    
-    AWAITING_TOOL_APPROVAL = "awaiting_tool_approval"   # Paused, needs external (user) approval for a tool invocation.
-    TOOL_DENIED = "tool_denied"                         # A proposed tool execution was denied by the user. Agent is processing the denial.
-    EXECUTING_TOOL = "executing_tool"                   # Tool has been approved (or auto-approved) and is currently running.
-    PROCESSING_TOOL_RESULT = "processing_tool_result"   # Received a tool's result, actively processing it (often leading to another LLM call).
-    
-    SHUTTING_DOWN = "shutting_down"               # Shutdown sequence has been initiated.
-    SHUTDOWN_COMPLETE = "shutdown_complete"       # Agent has fully stopped and released resources.
-    ERROR = "error"                               # An unrecoverable error has occurred. Agent might be non-operational.
-
-    def __str__(self) -> str:
-        return self.value
-
-    def is_initializing(self) -> bool:
-        """Checks if the agent is in any of the initializing phases."""
-        return self in [
-            AgentOperationalPhase.BOOTSTRAPPING,
-        ]
-
-    def is_processing(self) -> bool:
-        """Checks if the agent is in any active processing phase (post-initialization, pre-shutdown)."""
-        return self in [
-            AgentOperationalPhase.PROCESSING_USER_INPUT,
-            AgentOperationalPhase.AWAITING_LLM_RESPONSE,
-            AgentOperationalPhase.ANALYZING_LLM_RESPONSE,
-            AgentOperationalPhase.AWAITING_TOOL_APPROVAL,
-            AgentOperationalPhase.TOOL_DENIED,
-            AgentOperationalPhase.EXECUTING_TOOL,
-            AgentOperationalPhase.PROCESSING_TOOL_RESULT,
-        ]
-    
-    def is_terminal(self) -> bool:
-        """Checks if the phase is a terminal state (shutdown or error)."""
-        return self in [AgentOperationalPhase.SHUTDOWN_COMPLETE, AgentOperationalPhase.ERROR]

autobyteus/agent/group/agent_group.py

@@ -1,164 +0,0 @@
-# file: autobyteus/autobyteus/agent/group/agent_group.py
-import asyncio
-import logging
-import uuid
-from typing import List, Dict, Optional, Any
-
-from autobyteus.agent.context.agent_config import AgentConfig
-from autobyteus.agent.factory import AgentFactory
-from autobyteus.agent.agent import Agent 
-from autobyteus.agent.group.agent_group_context import AgentGroupContext
-from autobyteus.agent.message.send_message_to import SendMessageTo
-from autobyteus.agent.message.agent_input_user_message import AgentInputUserMessage
-from autobyteus.agent.streaming.agent_event_stream import AgentEventStream
-from autobyteus.llm.utils.response_types import CompleteResponse
-
-logger = logging.getLogger(__name__)
-
-class AgentGroup:
-    def __init__(self,
-                    agent_configs: List[AgentConfig],
-                    coordinator_config_name: str,
-                    group_id: Optional[str] = None): 
-        if not agent_configs or not all(isinstance(c, AgentConfig) for c in agent_configs):
-            raise TypeError("agent_configs must be a non-empty list of AgentConfig instances.")
-        if not coordinator_config_name or not isinstance(coordinator_config_name, str):
-            raise TypeError("coordinator_config_name must be a non-empty string.")
-        
-        self.group_id: str = group_id or f"group_{uuid.uuid4()}"
-        self.agent_factory = AgentFactory() # Get singleton instance
-        self._agent_configs_map: Dict[str, AgentConfig] = {
-            config.name: config for config in agent_configs
-        }
-        self.coordinator_config_name: str = coordinator_config_name
-        self.agents: List[Agent] = []
-        self.coordinator_agent: Optional[Agent] = None
-        self.group_context: Optional[AgentGroupContext] = None
-        self._is_initialized: bool = False
-        self._is_running: bool = False
-        
-        if self.coordinator_config_name not in self._agent_configs_map:
-            raise ValueError(f"Coordinator config name '{self.coordinator_config_name}' "
-                                f"not found in provided agent_configs. Available: {list(self._agent_configs_map.keys())}")
-        logger.info(f"AgentGroup '{self.group_id}' created with {len(agent_configs)} configurations. "
-                    f"Coordinator: '{self.coordinator_config_name}'.")
-        self._initialize_agents()
-
-    def _initialize_agents(self):
-        if self._is_initialized:
-            logger.warning(f"AgentGroup '{self.group_id}' agents already initialized. Skipping.")
-            return
-            
-        temp_agents_list: List[Agent] = []
-        temp_coordinator_agent: Optional[Agent] = None
-        for config_name, original_config in self._agent_configs_map.items():
-            
-            modified_tools = list(original_config.tools)
-            is_send_message_present = any(isinstance(tool, SendMessageTo) for tool in modified_tools)
-            if not is_send_message_present:
-                modified_tools.append(SendMessageTo())
-
-            # This logic correctly re-uses the user-provided LLM instance and other properties
-            # when creating the effective config for the agent factory.
-            effective_config = AgentConfig(
-                name=original_config.name,
-                role=original_config.role,
-                description=original_config.description,
-                llm_instance=original_config.llm_instance,
-                system_prompt=original_config.system_prompt,
-                tools=modified_tools, 
-                auto_execute_tools=original_config.auto_execute_tools,
-                use_xml_tool_format=original_config.use_xml_tool_format,
-                input_processors=original_config.input_processors,
-                llm_response_processors=original_config.llm_response_processors,
-                system_prompt_processors=original_config.system_prompt_processors,
-                workspace=original_config.workspace,
-                phase_hooks=original_config.phase_hooks,
-                initial_custom_data=original_config.initial_custom_data
-            )
-
-            try:
-                agent_instance = self.agent_factory.create_agent(config=effective_config)
-                temp_agents_list.append(agent_instance)
-                
-                if config_name == self.coordinator_config_name:
-                    temp_coordinator_agent = agent_instance
-                logger.debug(f"Agent '{agent_instance.agent_id}' (Role: {original_config.role}) created for group '{self.group_id}'.")
-            except Exception as e:
-                logger.error(f"Failed to create agent for config '{config_name}' for group '{self.group_id}': {e}", exc_info=True)
-                raise RuntimeError(f"Failed to initialize agent for config '{config_name}' in group '{self.group_id}'.") from e
-                
-        if not temp_coordinator_agent:
-            raise RuntimeError(f"Coordinator agent '{self.coordinator_config_name}' could not be instantiated.")
-        
-        self.agents = temp_agents_list
-        self.coordinator_agent = temp_coordinator_agent
-        self.group_context = AgentGroupContext(group_id=self.group_id, agents=self.agents, coordinator_agent_id=self.coordinator_agent.agent_id)
-        for agent in self.agents:
-            agent.context.custom_data['agent_group_context'] = self.group_context
-        self._is_initialized = True
-        logger.info(f"AgentGroup '{self.group_id}' all {len(self.agents)} agents initialized successfully.")
-
-    async def start(self):
-        if not self._is_initialized: raise RuntimeError(f"AgentGroup '{self.group_id}' must be initialized before starting.")
-        if self._is_running: logger.warning(f"AgentGroup '{self.group_id}' is already running."); return
-        logger.info(f"Starting all agents in AgentGroup '{self.group_id}'..."); self._is_running = True 
-        try:
-            for agent in self.agents:
-                if not agent.is_running:
-                    agent.start()
-            # Give loops a chance to start
-            await asyncio.sleep(0.01)
-            logger.info(f"All agents in AgentGroup '{self.group_id}' have been requested to start.")
-        except Exception as e:
-            self._is_running = False; logger.error(f"Error starting agents in AgentGroup '{self.group_id}': {e}", exc_info=True)
-            await self.stop(timeout=2.0); raise
-
-    async def stop(self, timeout: float = 10.0):
-        if not self._is_running and not any(a.is_running for a in self.agents): 
-            logger.info(f"AgentGroup '{self.group_id}' is already stopped or was never started."); self._is_running = False; return
-        logger.info(f"Stopping all agents in AgentGroup '{self.group_id}' with timeout {timeout}s...")
-        stop_tasks = [agent.stop(timeout=timeout) for agent in self.agents]
-        results = await asyncio.gather(*stop_tasks, return_exceptions=True)
-        for agent, result in zip(self.agents, results):
-            if isinstance(result, Exception): logger.error(f"Error stopping agent '{agent.agent_id}': {result}", exc_info=result)
-        self._is_running = False; logger.info(f"All agents in AgentGroup '{self.group_id}' have been requested to stop.")
-
-    async def process_task_for_coordinator(self, initial_input_content: str, user_id: Optional[str] = None) -> Any:
-        if not self.coordinator_agent: raise RuntimeError(f"Coordinator agent not set in group '{self.group_id}'.")
-        await self.start() 
-        final_response_aggregator = ""
-        output_stream_listener_task = None
-        streamer = None
-        try:
-            streamer = AgentEventStream(self.coordinator_agent) 
-            async def listen_for_final_output():
-                nonlocal final_response_aggregator
-                try:
-                    async for complete_response_data in streamer.stream_assistant_final_response():
-                        final_response_aggregator += complete_response_data.content
-                except Exception as e_stream:
-                    logger.error(f"Error streaming final output from coordinator: {e_stream}", exc_info=True)
-            output_stream_listener_task = asyncio.create_task(listen_for_final_output())
-            input_message = AgentInputUserMessage(content=initial_input_content, metadata={"user_id": user_id} if user_id else {})
-            await self.coordinator_agent.post_user_message(input_message)
-            
-            # Wait for the listener to finish, which happens after the agent is done and the stream closes.
-            if output_stream_listener_task: 
-                await output_stream_listener_task
-            
-            return final_response_aggregator
-        finally:
-            if output_stream_listener_task and not output_stream_listener_task.done():
-                output_stream_listener_task.cancel()
-            if streamer: await streamer.close()
-
-    def get_agent_by_id(self, agent_id: str) -> Optional[Agent]:
-        return next((agent for agent in self.agents if agent.agent_id == agent_id), None)
-
-    def get_agents_by_role(self, role_name: str) -> List[Agent]:
-        return [agent for agent in self.agents if agent.context.config.role == role_name]
-
-    @property
-    def is_running(self) -> bool:
-        return self._is_running and any(a.is_running for a in self.agents)