autobyteus 1.2.1__py3-none-any.whl → 1.3.0__py3-none-any.whl

autobyteus/agent/agent.py

@@ -4,7 +4,7 @@ import logging
 from typing import AsyncIterator, Optional, List, Any, Dict, TYPE_CHECKING 
 
 from autobyteus.agent.runtime.agent_runtime import AgentRuntime
-from autobyteus.agent.phases.phase_enum import AgentOperationalPhase 
+from autobyteus.agent.status.status_enum import AgentStatus 
 from autobyteus.agent.message.agent_input_user_message import AgentInputUserMessage
 from autobyteus.agent.message.inter_agent_message import InterAgentMessage
 from autobyteus.agent.events import UserMessageReceivedEvent, InterAgentMessageReceivedEvent, ToolExecutionApprovalEvent, BaseEvent 
@@ -81,8 +81,18 @@ class Agent:
         )
         await self._submit_event_to_runtime(approval_event)
 
-    def get_current_phase(self) -> AgentOperationalPhase: 
-        return self._runtime.current_phase_property 
+    def get_current_status(self) -> AgentStatus:
+        """
+        Returns the current status of the agent.
+
+        Returns:
+            AgentStatus: The current status of the agent.
+        """
+        # If the runtime hasn't started yet, we are uninitialized.
+        if not self._runtime:
+            return AgentStatus.UNINITIALIZED
+        
+        return self._runtime.current_status_property
     
     @property
     def is_running(self) -> bool:
@@ -102,5 +112,5 @@ class Agent:
 
 
     def __repr__(self) -> str:
-        phase_val = self._runtime.current_phase_property.value 
-        return f"<Agent agent_id='{self.agent_id}', current_phase='{phase_val}'>"
+        status_val = self._runtime.current_status_property.value 
+        return f"<Agent agent_id='{self.agent_id}', current_status='{status_val}'>"

autobyteus/agent/bootstrap_steps/__init__.py

@@ -1,21 +1,21 @@
 # file: autobyteus/autobyteus/agent/bootstrap_steps/__init__.py
 """
 Defines individual, self-contained steps for the agent bootstrapping process.
-These steps are orchestrated by the BootstrapAgentEventHandler.
+These steps are orchestrated by the BootstrapEventHandler.
 """
 
 from .base_bootstrap_step import BaseBootstrapStep
-from .agent_runtime_queue_initialization_step import AgentRuntimeQueueInitializationStep # UPDATED
 from .workspace_context_initialization_step import WorkspaceContextInitializationStep
 # ToolInitializationStep is no longer a bootstrap step.
 from .system_prompt_processing_step import SystemPromptProcessingStep
 from .mcp_server_prewarming_step import McpServerPrewarmingStep
+from .working_context_snapshot_restore_step import WorkingContextSnapshotRestoreStep
 # LLMConfigFinalizationStep and LLMInstanceCreationStep removed.
 
 __all__ = [
     "BaseBootstrapStep",
-    "AgentRuntimeQueueInitializationStep", # UPDATED
     "WorkspaceContextInitializationStep",
     "SystemPromptProcessingStep",
     "McpServerPrewarmingStep",
+    "WorkingContextSnapshotRestoreStep",
 ]

autobyteus/agent/bootstrap_steps/agent_bootstrapper.py

@@ -1,24 +1,19 @@
 # file: autobyteus/autobyteus/agent/bootstrap_steps/agent_bootstrapper.py
 import logging
-from typing import TYPE_CHECKING, List, Optional
+from typing import List, Optional
 
 from .base_bootstrap_step import BaseBootstrapStep
-from .agent_runtime_queue_initialization_step import AgentRuntimeQueueInitializationStep
 from .workspace_context_initialization_step import WorkspaceContextInitializationStep
 from .system_prompt_processing_step import SystemPromptProcessingStep
+from .working_context_snapshot_restore_step import WorkingContextSnapshotRestoreStep
 from .mcp_server_prewarming_step import McpServerPrewarmingStep
-from autobyteus.agent.events import AgentReadyEvent
-
-if TYPE_CHECKING:
-    from autobyteus.agent.context import AgentContext
-    from autobyteus.agent.phases import AgentPhaseManager
 
 logger = logging.getLogger(__name__)
 
 class AgentBootstrapper:
     """
-    Orchestrates the agent's bootstrapping process by executing a sequence of
-    self-contained bootstrap steps.
+    Provides the ordered bootstrap steps for the agent.
+    Execution is driven by bootstrap lifecycle events.
     """
     def __init__(self, steps: Optional[List[BaseBootstrapStep]] = None):
         """
@@ -30,61 +25,12 @@ class AgentBootstrapper:
         """
         if steps is None:
             self.bootstrap_steps: List[BaseBootstrapStep] = [
-                AgentRuntimeQueueInitializationStep(),
                 WorkspaceContextInitializationStep(),
                 McpServerPrewarmingStep(),
                 SystemPromptProcessingStep(),
+                WorkingContextSnapshotRestoreStep(),
             ]
             logger.debug("AgentBootstrapper initialized with default steps.")
         else:
             self.bootstrap_steps = steps
             logger.debug(f"AgentBootstrapper initialized with {len(steps)} custom steps.")
-
-    async def run(self, context: 'AgentContext', phase_manager: 'AgentPhaseManager') -> bool:
-        """
-        Executes the configured sequence of bootstrap steps.
-
-        Args:
-            context: The agent's context.
-            phase_manager: The agent's phase manager.
-
-        Returns:
-            True if all steps completed successfully, False otherwise.
-        """
-        agent_id = context.agent_id
-        
-        # Set the agent phase to BOOTSTRAPPING and wait for any associated hooks.
-        await phase_manager.notify_bootstrapping_started()
-        logger.info(f"Agent '{agent_id}': AgentBootstrapper starting execution. Phase set to BOOTSTRAPPING.")
-
-        for step_index, step_instance in enumerate(self.bootstrap_steps):
-            step_name = step_instance.__class__.__name__
-            logger.debug(f"Agent '{agent_id}': Executing bootstrap step {step_index + 1}/{len(self.bootstrap_steps)}: {step_name}")
-            
-            success = await step_instance.execute(context, phase_manager)
-            
-            if not success:
-                error_message = f"Bootstrap step {step_name} failed."
-                logger.error(f"Agent '{agent_id}': {error_message} Halting bootstrap process.")
-                # The step itself is responsible for detailed error logging.
-                # We are responsible for notifying the phase manager to set the agent to an error state.
-                await phase_manager.notify_error_occurred(
-                    error_message=f"Critical bootstrap failure at {step_name}",
-                    error_details=f"Agent '{agent_id}' failed during bootstrap step '{step_name}'. Check logs for details."
-                )
-                return False
-
-        logger.info(f"Agent '{agent_id}': All bootstrap steps completed successfully. Enqueuing AgentReadyEvent.")
-        # After successful bootstrapping, enqueue the ready event.
-        if context.state.input_event_queues:
-            await context.state.input_event_queues.enqueue_internal_system_event(AgentReadyEvent())
-        else: # pragma: no cover
-            # Should not happen if AgentRuntimeQueueInitializationStep is present and successful
-            logger.critical(f"Agent '{agent_id}': Bootstrap succeeded but input queues are not available to enqueue AgentReadyEvent.")
-            await phase_manager.notify_error_occurred(
-                error_message="Input queues unavailable after bootstrap",
-                error_details=f"Agent '{agent_id}' bootstrap process seemed to succeed, but input event queues are missing."
-            )
-            return False
-            
-        return True

autobyteus/agent/bootstrap_steps/base_bootstrap_step.py

@@ -5,7 +5,6 @@ from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
     from autobyteus.agent.context import AgentContext
-    from autobyteus.agent.phases import AgentPhaseManager
 
 logger = logging.getLogger(__name__)
 
@@ -18,14 +17,12 @@ class BaseBootstrapStep(ABC):
 
     @abstractmethod
     async def execute(self,
-                      context: 'AgentContext',
-                      phase_manager: 'AgentPhaseManager') -> bool:
+                      context: 'AgentContext') -> bool:
         """
         Executes the bootstrap step.
 
         Args:
             context: The agent's context, providing access to configuration and state.
-            phase_manager: The agent's phase manager for notifying phase transitions.
 
         Returns:
             True if the step completed successfully, False otherwise.

autobyteus/agent/bootstrap_steps/mcp_server_prewarming_step.py

@@ -9,7 +9,6 @@ from autobyteus.tools.tool_category import ToolCategory
 
 if TYPE_CHECKING:
     from autobyteus.agent.context import AgentContext
-    from autobyteus.agent.phases import AgentPhaseManager
 
 logger = logging.getLogger(__name__)
 
@@ -25,8 +24,7 @@ class McpServerPrewarmingStep(BaseBootstrapStep):
         logger.debug("McpServerPrewarmingStep initialized.")
 
     async def execute(self,
-                      context: 'AgentContext',
-                      phase_manager: 'AgentPhaseManager') -> bool:
+                      context: 'AgentContext') -> bool:
         agent_id = context.agent_id
         logger.info(f"Agent '{agent_id}': Executing McpServerPrewarmingStep.")
 

autobyteus/agent/bootstrap_steps/system_prompt_processing_step.py

@@ -3,12 +3,11 @@ import logging
 from typing import TYPE_CHECKING
 
 from .base_bootstrap_step import BaseBootstrapStep
-from autobyteus.agent.events import AgentErrorEvent
 from autobyteus.agent.system_prompt_processor.base_processor import BaseSystemPromptProcessor
+from autobyteus.agent.events import AgentErrorEvent
 
 if TYPE_CHECKING:
     from autobyteus.agent.context import AgentContext
-    from autobyteus.agent.phases import AgentPhaseManager
 
 logger = logging.getLogger(__name__)
 
@@ -22,10 +21,9 @@ class SystemPromptProcessingStep(BaseBootstrapStep):
         logger.debug("SystemPromptProcessingStep initialized.")
 
     async def execute(self,
-                      context: 'AgentContext',
-                      phase_manager: 'AgentPhaseManager') -> bool:
+                      context: 'AgentContext') -> bool:
         agent_id = context.agent_id
-        # The phase is now managed by the AgentBootstrapper.
+        # The status is managed by the bootstrap process.
         logger.info(f"Agent '{agent_id}': Executing SystemPromptProcessingStep.")
 
         try:
@@ -36,12 +34,22 @@ class SystemPromptProcessingStep(BaseBootstrapStep):
 
             # If a specific system_prompt is not provided in AgentConfig, fall back
             # to the default system_message from the LLM's own configuration.
-            current_system_prompt = context.config.system_prompt or llm_instance.config.system_message
+            base_system_prompt = context.config.system_prompt or llm_instance.config.system_message
             logger.debug(f"Agent '{agent_id}': Retrieved base system prompt.")
-            
+
             processor_instances = context.config.system_prompt_processors
             tool_instances_for_processor = context.tool_instances
 
+            # --- Validation Section ---
+            if processor_instances:
+                for p in processor_instances:
+                     if not isinstance(p, BaseSystemPromptProcessor):
+                        error_message = f"Invalid system prompt processor configuration type: {type(p)}. Expected BaseSystemPromptProcessor."
+                        logger.error(error_message)
+                        raise TypeError(error_message)
+
+            current_system_prompt = base_system_prompt
+
             if not processor_instances:
                 logger.debug(f"Agent '{agent_id}': No system prompt processors configured. Using system prompt as is.")
             else:
@@ -51,11 +59,6 @@ class SystemPromptProcessingStep(BaseBootstrapStep):
                 logger.debug(f"Agent '{agent_id}': Found {len(sorted_processors)} configured system prompt processors. Applying sequentially in order: {processor_names}")
 
                 for processor_instance in sorted_processors:
-                    if not isinstance(processor_instance, BaseSystemPromptProcessor):
-                        error_message = f"Agent '{agent_id}': Invalid system prompt processor configuration type: {type(processor_instance)}. Expected BaseSystemPromptProcessor."
-                        logger.error(error_message)
-                        raise TypeError(error_message)
-                    
                     processor_name = processor_instance.get_name()
                     try:
                         logger.debug(f"Agent '{agent_id}': Applying system prompt processor '{processor_name}'.")
@@ -93,7 +96,7 @@ class SystemPromptProcessingStep(BaseBootstrapStep):
             error_message = f"Agent '{agent_id}': Critical failure during system prompt processing step: {e}"
             logger.error(error_message, exc_info=True)
             if context.state.input_event_queues:
-                await context.input_event_queues.enqueue_internal_system_event(
+                await context.state.input_event_queues.enqueue_internal_system_event(
                     AgentErrorEvent(error_message=error_message, exception_details=str(e))
                 )
             return False

autobyteus/agent/bootstrap_steps/working_context_snapshot_restore_step.py

@@ -0,0 +1,38 @@
+import logging
+from typing import TYPE_CHECKING
+
+from .base_bootstrap_step import BaseBootstrapStep
+from autobyteus.memory.restore.working_context_snapshot_bootstrapper import WorkingContextSnapshotBootstrapper
+
+if TYPE_CHECKING:
+    from autobyteus.agent.context import AgentContext
+
+logger = logging.getLogger(__name__)
+
+
+class WorkingContextSnapshotRestoreStep(BaseBootstrapStep):
+    def __init__(self, bootstrapper: WorkingContextSnapshotBootstrapper | None = None) -> None:
+        self._bootstrapper = bootstrapper or WorkingContextSnapshotBootstrapper()
+        logger.debug("WorkingContextSnapshotRestoreStep initialized.")
+
+    async def execute(self, context: "AgentContext") -> bool:
+        restore_options = getattr(context.state, "restore_options", None)
+        if not restore_options:
+            return True
+
+        memory_manager = getattr(context.state, "memory_manager", None)
+        if not memory_manager:
+            logger.error("WorkingContextSnapshotRestoreStep requires a memory manager to restore working context snapshot.")
+            return False
+
+        system_prompt = context.state.processed_system_prompt
+        if not system_prompt:
+            llm_instance = context.llm_instance
+            system_prompt = llm_instance.config.system_message if llm_instance else ""
+
+        try:
+            self._bootstrapper.bootstrap(memory_manager, system_prompt, restore_options)
+            return True
+        except Exception as exc:  # pragma: no cover - defensive
+            logger.error("WorkingContextSnapshotRestoreStep failed: %s", exc, exc_info=True)
+            return False

autobyteus/agent/bootstrap_steps/workspace_context_initialization_step.py

@@ -6,7 +6,6 @@ from .base_bootstrap_step import BaseBootstrapStep
 
 if TYPE_CHECKING:
     from autobyteus.agent.context import AgentContext
-    from autobyteus.agent.phases import AgentPhaseManager
 
 logger = logging.getLogger(__name__)
 
@@ -19,8 +18,7 @@ class WorkspaceContextInitializationStep(BaseBootstrapStep):
         logger.debug("WorkspaceContextInitializationStep initialized.")
 
     async def execute(self,
-                      context: 'AgentContext',
-                      phase_manager: 'AgentPhaseManager') -> bool:
+                      context: 'AgentContext') -> bool:
         agent_id = context.agent_id
         logger.info(f"Agent '{agent_id}': Executing WorkspaceContextInitializationStep.")
 
@@ -43,5 +41,5 @@ class WorkspaceContextInitializationStep(BaseBootstrapStep):
             error_message = f"Agent '{agent_id}': Critical failure during WorkspaceContextInitializationStep: {e}"
             logger.error(error_message, exc_info=True)
             # No easy way to enqueue an error event here if queues aren't even initialized yet.
-            # The failure of a bootstrap step is handled by the bootstrapper, which will log and set error phase.
+            # The failure of a bootstrap step is handled by the bootstrapper, which will log and set error status.
             return False

autobyteus/agent/context/agent_config.py

@@ -4,30 +4,33 @@ import copy
 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
-from autobyteus.agent.llm_response_processor import ProviderAwareToolUsageProcessor, BaseLLMResponseProcessor
+from autobyteus.agent.system_prompt_processor import ToolManifestInjectorProcessor, BaseSystemPromptProcessor, AvailableSkillsProcessor
+from autobyteus.agent.llm_response_processor import BaseLLMResponseProcessor
+from autobyteus.utils.tool_call_format import resolve_tool_call_format
 
 
 if TYPE_CHECKING:
     from autobyteus.tools.base_tool import BaseTool
     from autobyteus.agent.input_processor import BaseAgentUserInputMessageProcessor
     from autobyteus.agent.tool_execution_result_processor import BaseToolExecutionResultProcessor
+    from autobyteus.agent.tool_invocation_preprocessor import BaseToolInvocationPreprocessor
     from autobyteus.llm.base_llm import BaseLLM
     from autobyteus.agent.workspace.base_workspace import BaseAgentWorkspace
-    from autobyteus.agent.hooks.base_phase_hook import BasePhaseHook
+    from autobyteus.agent.lifecycle import BaseLifecycleEventProcessor
 
 logger = logging.getLogger(__name__)
 
+
 class AgentConfig:
     """
     Represents the complete, static configuration for an agent instance.
     This is the single source of truth for an agent's definition, including
     its identity, capabilities, and default behaviors.
     """
-    # Use the new ProviderAwareToolUsageProcessor as the default
-    DEFAULT_LLM_RESPONSE_PROCESSORS = [ProviderAwareToolUsageProcessor()]
+    # Default to no LLM response processors; tool parsing happens during streaming.
+    DEFAULT_LLM_RESPONSE_PROCESSORS: List['BaseLLMResponseProcessor'] = []
     # Use the new, single, unified processor as the default
-    DEFAULT_SYSTEM_PROMPT_PROCESSORS = [ToolManifestInjectorProcessor()]
+    DEFAULT_SYSTEM_PROMPT_PROCESSORS = [ToolManifestInjectorProcessor(), AvailableSkillsProcessor()]
 
     def __init__(self,
                  name: str,
@@ -37,14 +40,16 @@ class AgentConfig:
                  system_prompt: Optional[str] = None,
                  tools: Optional[List['BaseTool']] = None,
                  auto_execute_tools: bool = True,
-                 use_xml_tool_format: bool = False,
                  input_processors: Optional[List['BaseAgentUserInputMessageProcessor']] = None,
                  llm_response_processors: Optional[List['BaseLLMResponseProcessor']] = None,
                  system_prompt_processors: Optional[List['BaseSystemPromptProcessor']] = None,
                  tool_execution_result_processors: Optional[List['BaseToolExecutionResultProcessor']] = None,
+                 tool_invocation_preprocessors: Optional[List['BaseToolInvocationPreprocessor']] = None,
                  workspace: Optional['BaseAgentWorkspace'] = None,
-                 phase_hooks: Optional[List['BasePhaseHook']] = None,
-                 initial_custom_data: Optional[Dict[str, Any]] = None):
+                 lifecycle_processors: Optional[List['BaseLifecycleEventProcessor']] = None,
+                 initial_custom_data: Optional[Dict[str, Any]] = None,
+                 skills: Optional[List[str]] = None,
+                 memory_dir: Optional[str] = None):
         """
         Initializes the AgentConfig.
 
@@ -58,16 +63,16 @@ class AgentConfig:
                            llm_instance's config will be used as the base.
             tools: An optional list of pre-initialized tool instances (subclasses of BaseTool).
             auto_execute_tools: If True, the agent will execute tools without approval.
-            use_xml_tool_format: If True, forces the agent to use XML format for tool
-                                 definitions and parsing, overriding provider defaults.
             input_processors: A list of input processor instances.
             llm_response_processors: A list of LLM response processor instances.
             system_prompt_processors: A list of system prompt processor instances.
             tool_execution_result_processors: A list of tool execution result processor instances.
             workspace: An optional pre-initialized workspace instance for the agent.
-            phase_hooks: An optional list of phase transition hook instances.
+            lifecycle_processors: An optional list of lifecycle processor instances.
             initial_custom_data: An optional dictionary of data to pre-populate
                                  the agent's runtime state `custom_data`.
+            skills: An optional list of skill names or paths to be preloaded for this agent.
+            memory_dir: Optional override for the agent memory base directory.
         """
         self.name = name
         self.role = role
@@ -77,15 +82,35 @@ class AgentConfig:
         self.tools = tools or []
         self.workspace = workspace
         self.auto_execute_tools = auto_execute_tools
-        self.use_xml_tool_format = use_xml_tool_format
         self.input_processors = input_processors or []
         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)
+        
+        # Initialize processors first
+        default_processors = self.system_prompt_processors = system_prompt_processors if system_prompt_processors is not None else list(self.DEFAULT_SYSTEM_PROMPT_PROCESSORS)
+        
         self.tool_execution_result_processors = tool_execution_result_processors or []
-        self.phase_hooks = phase_hooks or []
+        self.tool_invocation_preprocessors = tool_invocation_preprocessors or []
+        self.lifecycle_processors = lifecycle_processors or []
         self.initial_custom_data = initial_custom_data
+        self.skills = skills or []
+        self.memory_dir = memory_dir
+
+        # Filter out ToolManifestInjectorProcessor if in API_TOOL_CALL mode
+        tool_call_format = resolve_tool_call_format()
+        if tool_call_format == "api_tool_call":
+            self.system_prompt_processors = [
+                p for p in default_processors 
+                if not isinstance(p, ToolManifestInjectorProcessor)
+            ]
+        else:
+            self.system_prompt_processors = default_processors
 
-        logger.debug(f"AgentConfig created for name '{self.name}', role '{self.role}'. XML tool format override: {self.use_xml_tool_format}")
+        logger.debug(
+            "AgentConfig created for name='%s', role='%s'. Tool call format: %s",
+            self.name,
+            self.role,
+            tool_call_format,
+        )
 
     def copy(self) -> 'AgentConfig':
         """
@@ -102,15 +127,17 @@ class AgentConfig:
             system_prompt=self.system_prompt,
             tools=self.tools.copy(),  # Shallow copy the list, but reference the original tool instances
             auto_execute_tools=self.auto_execute_tools,
-            use_xml_tool_format=self.use_xml_tool_format,
             input_processors=self.input_processors.copy(), # Shallow copy the list
             llm_response_processors=self.llm_response_processors.copy(), # Shallow copy the list
             system_prompt_processors=self.system_prompt_processors.copy(), # Shallow copy the list
             tool_execution_result_processors=self.tool_execution_result_processors.copy(), # Shallow copy the list
+            tool_invocation_preprocessors=self.tool_invocation_preprocessors.copy(),
             workspace=self.workspace,  # Pass by reference, do not copy
-            phase_hooks=self.phase_hooks.copy(), # Shallow copy the list
-            initial_custom_data=copy.deepcopy(self.initial_custom_data) # Deep copy for simple data
+            lifecycle_processors=self.lifecycle_processors.copy(), # Shallow copy the list
+            initial_custom_data=copy.deepcopy(self.initial_custom_data), # Deep copy for simple data
+            skills=self.skills.copy(), # Shallow copy the list
+            memory_dir=self.memory_dir,
         )
 
     def __repr__(self) -> str:
-        return (f"AgentConfig(name='{self.name}', role='{self.role}', llm_instance='{self.llm_instance.__class__.__name__}', workspace_configured={self.workspace is not None})")
+        return (f"AgentConfig(name='{self.name}', role='{self.role}', llm_instance='{self.llm_instance.__class__.__name__}', workspace_configured={self.workspace is not None}, skills={self.skills})")

autobyteus/agent/context/agent_context.py

@@ -1,8 +1,8 @@
 # file: autobyteus/autobyteus/agent/context/agent_context.py
 import logging
-from typing import TYPE_CHECKING, List, Dict, Any, Optional
+from typing import TYPE_CHECKING, Dict, Any, Optional
 
-from autobyteus.agent.phases import AgentOperationalPhase 
+ 
 
 if TYPE_CHECKING:
     from .agent_config import AgentConfig 
@@ -11,9 +11,13 @@ if TYPE_CHECKING:
     from autobyteus.tools.base_tool import BaseTool
     from autobyteus.agent.events.agent_input_event_queue_manager import AgentInputEventQueueManager 
     from autobyteus.agent.tool_invocation import ToolInvocation
+    from autobyteus.agent.events.event_store import AgentEventStore
+    from autobyteus.agent.status.status_deriver import AgentStatusDeriver
     # LLMConfig no longer needed here
     from autobyteus.agent.workspace.base_workspace import BaseAgentWorkspace
-    from autobyteus.agent.phases import AgentPhaseManager 
+    
+from autobyteus.agent.status.status_enum import AgentStatus 
+from autobyteus.agent.status.manager import AgentStatusManager 
 
 logger = logging.getLogger(__name__)
 
@@ -65,22 +69,26 @@ class AgentContext:
         return self.state.input_event_queues
 
     @property
-    def current_phase(self) -> 'AgentOperationalPhase': 
-        return self.state.current_phase
+    def current_status(self) -> 'AgentStatus': 
+        return self.state.current_status
+
+    @current_status.setter
+    def current_status(self, value: 'AgentStatus'): 
+        if not isinstance(value, AgentStatus): # pragma: no cover
+            raise TypeError(f"current_status must be an AgentStatus instance. Got {type(value)}")
+        self.state.current_status = value
 
-    @current_phase.setter
-    def current_phase(self, value: 'AgentOperationalPhase'): 
-        if not isinstance(value, AgentOperationalPhase): # pragma: no cover
-            raise TypeError(f"current_phase must be an AgentOperationalPhase instance. Got {type(value)}")
-        self.state.current_phase = value
+    @property
+    def status_manager(self) -> Optional['AgentStatusManager']: 
+        return self.state.status_manager_ref
 
     @property
-    def phase_manager(self) -> Optional['AgentPhaseManager']: 
-        return self.state.phase_manager_ref
+    def event_store(self) -> Optional['AgentEventStore']:
+        return self.state.event_store
 
     @property
-    def conversation_history(self) -> List[Dict[str, Any]]:
-        return self.state.conversation_history
+    def status_deriver(self) -> Optional['AgentStatusDeriver']:
+        return self.state.status_deriver
 
     @property
     def pending_tool_approvals(self) -> Dict[str, 'ToolInvocation']:
@@ -104,9 +112,6 @@ class AgentContext:
 
     # final_llm_config_for_creation property removed
 
-    def add_message_to_history(self, message: Dict[str, Any]) -> None:
-        self.state.add_message_to_history(message)
-
     def get_tool(self, tool_name: str) -> Optional['BaseTool']:
         tool = self.tool_instances.get(tool_name) 
         if not tool: # pragma: no cover
@@ -123,7 +128,7 @@ class AgentContext:
     def __repr__(self) -> str:
         input_q_status = "Initialized" if self.state.input_event_queues is not None else "Pending Init"
         return (f"AgentContext(agent_id='{self.agent_id}', "
-                f"current_phase='{self.state.current_phase.value}', " 
+                f"current_status='{self.state.current_status.value}', " 
                 f"llm_initialized={self.state.llm_instance is not None}, "
                 f"tools_initialized={self.state.tool_instances is not None}, "
                 f"input_queues_status='{input_q_status}')")