autobyteus 1.1.0__py3-none-any.whl → 1.1.1__py3-none-any.whl

autobyteus/agent/bootstrap_steps/agent_bootstrapper.py

@@ -10,7 +10,7 @@ from autobyteus.agent.events import AgentReadyEvent
 
 if TYPE_CHECKING:
     from autobyteus.agent.context import AgentContext
-    from autobyteus.agent.context.agent_phase_manager import AgentPhaseManager
+    from autobyteus.agent.phases import AgentPhaseManager
 
 logger = logging.getLogger(__name__)
 

autobyteus/agent/bootstrap_steps/agent_runtime_queue_initialization_step.py

@@ -8,7 +8,7 @@ from autobyteus.agent.events import AgentErrorEvent, AgentInputEventQueueManager
 
 if TYPE_CHECKING:
     from autobyteus.agent.context import AgentContext
-    from autobyteus.agent.context.agent_phase_manager import AgentPhaseManager
+    from autobyteus.agent.phases import AgentPhaseManager
 
 logger = logging.getLogger(__name__)
 

autobyteus/agent/bootstrap_steps/base_bootstrap_step.py

@@ -5,7 +5,7 @@ from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
     from autobyteus.agent.context import AgentContext
-    from autobyteus.agent.context.agent_phase_manager import AgentPhaseManager
+    from autobyteus.agent.phases import AgentPhaseManager
 
 logger = logging.getLogger(__name__)
 

autobyteus/agent/bootstrap_steps/system_prompt_processing_step.py

@@ -8,7 +8,7 @@ from autobyteus.agent.system_prompt_processor.base_processor import BaseSystemPr
 
 if TYPE_CHECKING:
     from autobyteus.agent.context import AgentContext
-    from autobyteus.agent.context.agent_phase_manager import AgentPhaseManager
+    from autobyteus.agent.phases import AgentPhaseManager
 
 logger = logging.getLogger(__name__)
 

autobyteus/agent/bootstrap_steps/workspace_context_initialization_step.py

@@ -6,7 +6,7 @@ from .base_bootstrap_step import BaseBootstrapStep
 
 if TYPE_CHECKING:
     from autobyteus.agent.context import AgentContext
-    from autobyteus.agent.context.agent_phase_manager import AgentPhaseManager
+    from autobyteus.agent.phases import AgentPhaseManager
 
 logger = logging.getLogger(__name__)
 

autobyteus/agent/context/__init__.py

@@ -5,14 +5,9 @@ Components related to the agent's runtime context, state, config, and status man
 from .agent_config import AgentConfig
 from .agent_runtime_state import AgentRuntimeState
 from .agent_context import AgentContext 
-from .agent_phase_manager import AgentPhaseManager
-from .phases import AgentOperationalPhase
-
 
 __all__ = [
     "AgentContext",
     "AgentConfig", 
     "AgentRuntimeState", 
-    "AgentPhaseManager",
-    "AgentOperationalPhase",
 ]

autobyteus/agent/context/agent_config.py

@@ -1,6 +1,6 @@
 # file: autobyteus/autobyteus/agent/context/agent_config.py
 import logging
-from typing import List, Optional, Union, Tuple, TYPE_CHECKING
+from typing import List, Optional, Union, Tuple, TYPE_CHECKING, Dict, Any
 
 # Correctly import the new master processor and the base class
 from autobyteus.agent.system_prompt_processor import ToolManifestInjectorProcessor, BaseSystemPromptProcessor
@@ -40,7 +40,8 @@ class AgentConfig:
                  llm_response_processors: Optional[List['BaseLLMResponseProcessor']] = None,
                  system_prompt_processors: Optional[List['BaseSystemPromptProcessor']] = None,
                  workspace: Optional['BaseAgentWorkspace'] = None,
-                 phase_hooks: Optional[List['BasePhaseHook']] = None):
+                 phase_hooks: Optional[List['BasePhaseHook']] = None,
+                 initial_custom_data: Optional[Dict[str, Any]] = None):
         """
         Initializes the AgentConfig.
 
@@ -59,6 +60,8 @@ class AgentConfig:
             system_prompt_processors: A list of system prompt processor instances.
             workspace: An optional pre-initialized workspace instance for the agent.
             phase_hooks: An optional list of phase transition hook instances.
+            initial_custom_data: An optional dictionary of data to pre-populate
+                                 the agent's runtime state `custom_data`.
         """
         self.name = name
         self.role = role
@@ -73,6 +76,7 @@ class AgentConfig:
         self.llm_response_processors = llm_response_processors if llm_response_processors is not None else list(self.DEFAULT_LLM_RESPONSE_PROCESSORS)
         self.system_prompt_processors = system_prompt_processors if system_prompt_processors is not None else list(self.DEFAULT_SYSTEM_PROMPT_PROCESSORS)
         self.phase_hooks = phase_hooks or []
+        self.initial_custom_data = initial_custom_data
 
         logger.debug(f"AgentConfig created for name '{self.name}', role '{self.role}'.")
 

autobyteus/agent/context/agent_context.py

@@ -2,7 +2,7 @@
 import logging
 from typing import TYPE_CHECKING, List, Dict, Any, Optional
 
-from .phases import AgentOperationalPhase 
+from autobyteus.agent.phases import AgentOperationalPhase 
 
 if TYPE_CHECKING:
     from .agent_config import AgentConfig 
@@ -13,7 +13,7 @@ if TYPE_CHECKING:
     from autobyteus.agent.tool_invocation import ToolInvocation
     # LLMConfig no longer needed here
     from autobyteus.agent.workspace.base_workspace import BaseAgentWorkspace
-    from autobyteus.agent.context.agent_phase_manager import AgentPhaseManager 
+    from autobyteus.agent.phases import AgentPhaseManager 
 
 logger = logging.getLogger(__name__)
 
@@ -48,9 +48,6 @@ class AgentContext:
     @property
     def auto_execute_tools(self) -> bool:
         return self.config.auto_execute_tools
-    
-    # llm_model_name property removed
-    # custom_llm_config property removed
 
     @property
     def llm_instance(self) -> Optional['BaseLLM']:

autobyteus/agent/context/agent_phase_manager.py

@@ -3,7 +3,7 @@ import asyncio
 import logging
 from typing import TYPE_CHECKING, Optional, Dict, Any
 
-from .phases import AgentOperationalPhase
+from autobyteus.agent.phases import AgentOperationalPhase, phase_transition
 
 if TYPE_CHECKING:
     from autobyteus.agent.context.agent_context import AgentContext
@@ -84,6 +84,11 @@ class AgentPhaseManager:
         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")
@@ -92,9 +97,19 @@ class AgentPhaseManager:
         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
@@ -102,8 +117,17 @@ class AgentPhaseManager:
         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]:
+        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:
@@ -111,30 +135,79 @@ class AgentPhaseManager:
         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:
-        # The notifier's notify_phase_awaiting_tool_approval_started method no longer takes tool_details.
-        # The phase event itself is the signal. Tool data comes via queue.
         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._transition_phase(AgentOperationalPhase.ANALYZING_LLM_RESPONSE, "notify_phase_analyzing_llm_response_started", additional_data={"denial_for_tool": tool_name})
+            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")
@@ -143,6 +216,17 @@ class AgentPhaseManager:
         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}
@@ -150,12 +234,28 @@ class AgentPhaseManager:
         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:

autobyteus/agent/context/agent_runtime_state.py

@@ -7,14 +7,14 @@ from autobyteus.agent.events.agent_input_event_queue_manager import AgentInputEv
 # from autobyteus.agent.events.agent_output_data_manager import AgentOutputDataManager       
 
 from autobyteus.llm.base_llm import BaseLLM
-from .phases import AgentOperationalPhase 
+from autobyteus.agent.phases import AgentOperationalPhase 
 from autobyteus.agent.workspace.base_workspace import BaseAgentWorkspace
 from autobyteus.agent.tool_invocation import ToolInvocation
 # LLMConfig is no longer needed here
 # from autobyteus.llm.utils.llm_config import LLMConfig 
 
 if TYPE_CHECKING:
-    from autobyteus.agent.context.agent_phase_manager import AgentPhaseManager 
+    from autobyteus.agent.phases import AgentPhaseManager 
     from autobyteus.tools.base_tool import BaseTool 
 
 logger = logging.getLogger(__name__)

autobyteus/agent/context/phases.py

@@ -15,6 +15,7 @@ class AgentOperationalPhase(str, Enum):
     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).
     
@@ -38,6 +39,7 @@ class AgentOperationalPhase(str, Enum):
             AgentOperationalPhase.AWAITING_LLM_RESPONSE,
             AgentOperationalPhase.ANALYZING_LLM_RESPONSE,
             AgentOperationalPhase.AWAITING_TOOL_APPROVAL,
+            AgentOperationalPhase.TOOL_DENIED,
             AgentOperationalPhase.EXECUTING_TOOL,
             AgentOperationalPhase.PROCESSING_TOOL_RESULT,
         ]

autobyteus/agent/events/__init__.py

@@ -12,17 +12,11 @@ from .agent_events import (
     LifecycleEvent,
     AgentProcessingEvent,
     # Agent Phase-Specific Base Events
-    AgentPreparationEvent, 
     AgentOperationalEvent,
     # Specific Lifecycle Events
     AgentReadyEvent, 
     AgentStoppedEvent,
     AgentErrorEvent,
-    # DEPRECATED Initialization Events
-    CreateToolInstancesEvent, 
-    ProcessSystemPromptEvent,
-    FinalizeLLMConfigEvent,
-    CreateLLMInstanceEvent,
     # Regular Agent Processing Events
     UserMessageReceivedEvent, 
     InterAgentMessageReceivedEvent, 
@@ -42,15 +36,10 @@ __all__ = [
     "BaseEvent",
     "LifecycleEvent",
     "AgentProcessingEvent",
-    "AgentPreparationEvent", 
     "AgentOperationalEvent", 
     "AgentReadyEvent", 
     "AgentStoppedEvent",
     "AgentErrorEvent",
-    "CreateToolInstancesEvent", 
-    "ProcessSystemPromptEvent", 
-    "FinalizeLLMConfigEvent",   
-    "CreateLLMInstanceEvent",   
     "UserMessageReceivedEvent",
     "InterAgentMessageReceivedEvent",
     "LLMUserMessageReadyEvent", 

autobyteus/agent/events/agent_events.py

@@ -25,43 +25,6 @@ class AgentProcessingEvent(BaseEvent):
     """Base class for events related to the agent's internal data processing and task execution logic."""
 
 
-# --- Agent Initialization Sequence Events ---
-@dataclass
-class AgentPreparationEvent(AgentProcessingEvent):
-    """Base class for events that are part of the agent's preparation/initialization sequence."""
-    pass
-
-# BootstrapAgentEvent REMOVED
-
-@dataclass
-class CreateToolInstancesEvent(AgentPreparationEvent): 
-    """
-    DEPRECATED. Initialization is now handled directly by the agent worker.
-    """
-    pass
-
-@dataclass
-class ProcessSystemPromptEvent(AgentPreparationEvent):
-    """
-    DEPRECATED. Initialization is now handled directly by the agent worker.
-    """
-    pass
-
-@dataclass
-class FinalizeLLMConfigEvent(AgentPreparationEvent):
-    """
-    DEPRECATED. Initialization is now handled directly by the agent worker.
-    """
-    pass
-
-@dataclass
-class CreateLLMInstanceEvent(AgentPreparationEvent):
-    """
-    DEPRECATED. Initialization is now handled directly by the agent worker.
-    """
-    pass
-
-
 # --- Agent Operational Phase Events ---
 @dataclass
 class AgentOperationalEvent(AgentProcessingEvent): 

autobyteus/agent/events/notifiers.py

@@ -4,7 +4,7 @@ from typing import Optional, Dict, Any, TYPE_CHECKING
 
 from autobyteus.events.event_emitter import EventEmitter
 from autobyteus.events.event_types import EventType 
-from autobyteus.agent.context.phases import AgentOperationalPhase
+from autobyteus.agent.phases import AgentOperationalPhase
 
 if TYPE_CHECKING:
     from autobyteus.llm.utils.response_types import ChunkResponse, CompleteResponse 
@@ -27,7 +27,15 @@ class AgentExternalEventNotifier(EventEmitter):
             emit_kwargs["payload"] = payload_content 
         
         self.emit(event_type, **emit_kwargs) 
-        logger.info(f"AgentExternalEventNotifier (NotifierID: {self.object_id}, AgentID: {self.agent_id}) emitted {event_type.name}. Kwarg keys for emit: {list(emit_kwargs.keys())}")
+        log_message = (
+            f"AgentExternalEventNotifier (NotifierID: {self.object_id}, AgentID: {self.agent_id}) "
+            f"emitted {event_type.name}. Kwarg keys for emit: {list(emit_kwargs.keys())}"
+        )
+        # Reduce log level for high-frequency events like streaming chunks
+        if event_type == EventType.AGENT_DATA_ASSISTANT_CHUNK:
+            logger.debug(log_message)
+        else:
+            logger.info(log_message)
 
 
     def _emit_phase_change(self, 
@@ -57,10 +65,18 @@ class AgentExternalEventNotifier(EventEmitter):
         self._emit_phase_change(EventType.AGENT_PHASE_PROCESSING_USER_INPUT_STARTED, AgentOperationalPhase.PROCESSING_USER_INPUT, old_phase, additional_data=data)
     def notify_phase_awaiting_llm_response_started(self, old_phase: Optional[AgentOperationalPhase]):
         self._emit_phase_change(EventType.AGENT_PHASE_AWAITING_LLM_RESPONSE_STARTED, AgentOperationalPhase.AWAITING_LLM_RESPONSE, old_phase)
+
     def notify_phase_analyzing_llm_response_started(self, old_phase: Optional[AgentOperationalPhase]):
         self._emit_phase_change(EventType.AGENT_PHASE_ANALYZING_LLM_RESPONSE_STARTED, AgentOperationalPhase.ANALYZING_LLM_RESPONSE, old_phase)
+
     def notify_phase_awaiting_tool_approval_started(self, old_phase: Optional[AgentOperationalPhase]):
         self._emit_phase_change(EventType.AGENT_PHASE_AWAITING_TOOL_APPROVAL_STARTED, AgentOperationalPhase.AWAITING_TOOL_APPROVAL, old_phase)
+
+    def notify_phase_tool_denied_started(self, old_phase: Optional[AgentOperationalPhase], tool_name: Optional[str], denial_for_tool: Optional[str]):
+        data = {"tool_name": tool_name, "denial_for_tool": denial_for_tool}
+        # Assuming EventType.AGENT_PHASE_TOOL_DENIED_STARTED exists in the main EventType enum
+        self._emit_phase_change(EventType.AGENT_PHASE_TOOL_DENIED_STARTED, AgentOperationalPhase.TOOL_DENIED, old_phase, additional_data=data)
+
     def notify_phase_executing_tool_started(self, old_phase: Optional[AgentOperationalPhase], tool_name: str):
         data = {"tool_name": tool_name}
         self._emit_phase_change(EventType.AGENT_PHASE_EXECUTING_TOOL_STARTED, AgentOperationalPhase.EXECUTING_TOOL, old_phase, additional_data=data)
@@ -81,13 +97,11 @@ class AgentExternalEventNotifier(EventEmitter):
     def notify_agent_data_assistant_chunk_stream_end(self): 
         self._emit_event(EventType.AGENT_DATA_ASSISTANT_CHUNK_STREAM_END) 
 
-    # RENAMED METHOD
-    def notify_agent_data_assistant_complete_response(self, complete_response: 'CompleteResponse'): # RENAMED from notify_agent_data_assistant_final_message
-        # Use RENAMED EventType
+    def notify_agent_data_assistant_complete_response(self, complete_response: 'CompleteResponse'):
         self._emit_event(EventType.AGENT_DATA_ASSISTANT_COMPLETE_RESPONSE, payload_content=complete_response) 
 
-    def notify_agent_data_tool_log(self, log_entry: str): 
-        self._emit_event(EventType.AGENT_DATA_TOOL_LOG, payload_content=log_entry) 
+    def notify_agent_data_tool_log(self, log_data: Dict[str, Any]): 
+        self._emit_event(EventType.AGENT_DATA_TOOL_LOG, payload_content=log_data) 
     
     def notify_agent_data_tool_log_stream_end(self): 
         self._emit_event(EventType.AGENT_DATA_TOOL_LOG_STREAM_END) 
@@ -95,6 +109,10 @@ class AgentExternalEventNotifier(EventEmitter):
     def notify_agent_request_tool_invocation_approval(self, approval_data: Dict[str, Any]): 
         self._emit_event(EventType.AGENT_REQUEST_TOOL_INVOCATION_APPROVAL, payload_content=approval_data) 
 
+    def notify_agent_tool_invocation_auto_executing(self, auto_exec_data: Dict[str, Any]):
+        """Notifies that a tool is being automatically executed."""
+        self._emit_event(EventType.AGENT_TOOL_INVOCATION_AUTO_EXECUTING, payload_content=auto_exec_data)
+
     def notify_agent_error_output_generation(self, error_source: str, error_message: str, error_details: Optional[str] = None): 
         payload_dict = { 
             "source": error_source,

autobyteus/agent/events/worker_event_dispatcher.py

@@ -4,7 +4,7 @@ import logging
 import traceback
 from typing import TYPE_CHECKING, Optional
 
-from autobyteus.agent.context.phases import AgentOperationalPhase
+from autobyteus.agent.phases import AgentOperationalPhase
 from autobyteus.agent.events.agent_events import ( # Updated relative import path if needed, but BaseEvent is fine
     BaseEvent,
     AgentReadyEvent,

autobyteus/agent/factory/agent_factory.py

@@ -75,8 +75,12 @@ class AgentFactory(metaclass=SingletonMeta):
                         ) -> 'AgentRuntime': 
         from autobyteus.agent.runtime.agent_runtime import AgentRuntime 
 
-        # The workspace is now passed directly from the config
-        runtime_state = AgentRuntimeState(agent_id=agent_id, workspace=config.workspace)
+        # The workspace and initial custom data are now passed directly from the config to the state.
+        runtime_state = AgentRuntimeState(
+            agent_id=agent_id,
+            workspace=config.workspace,
+            custom_data=config.initial_custom_data
+        )
         
         # --- Set pre-initialized instances on the state ---
         runtime_state.llm_instance = config.llm_instance

autobyteus/agent/group/agent_group.py

@@ -58,10 +58,13 @@ class AgentGroup:
             if not is_send_message_present:
                 modified_tools.append(SendMessageTo())
 
-            # This logic correctly re-uses the user-provided LLM instance when creating the effective config.
+            # 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, # Pass the instance through
+                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,
@@ -69,7 +72,9 @@ class AgentGroup:
                 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 # Pass the workspace through
+                workspace=original_config.workspace,
+                phase_hooks=original_config.phase_hooks,
+                initial_custom_data=original_config.initial_custom_data
             )
 
             try:
@@ -130,14 +135,18 @@ class AgentGroup:
             async def listen_for_final_output():
                 nonlocal final_response_aggregator
                 try:
-                    async for complete_response in streamer.stream_assistant_final_messages():
-                        final_response_aggregator += complete_response.content
+                    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)
-            if output_stream_listener_task: await output_stream_listener_task
+            
+            # 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():