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

autobyteus/agent/context/agent_runtime_state.py

@@ -1,13 +1,15 @@
 # file: autobyteus/autobyteus/agent/context/agent_runtime_state.py
 import logging
-from typing import List, Dict, Any, Optional, TYPE_CHECKING
+from typing import Dict, Any, Optional, TYPE_CHECKING
 
 from autobyteus.agent.events.agent_input_event_queue_manager import AgentInputEventQueueManager 
+from autobyteus.agent.events.event_store import AgentEventStore
+from autobyteus.agent.status.status_deriver import AgentStatusDeriver
 # AgentOutputDataManager is no longer part of AgentRuntimeState
 # from autobyteus.agent.events.agent_output_data_manager import AgentOutputDataManager       
 
 from autobyteus.llm.base_llm import BaseLLM
-from autobyteus.agent.phases import AgentOperationalPhase 
+from autobyteus.agent.status.status_enum import AgentStatus 
 from autobyteus.agent.workspace.base_workspace import BaseAgentWorkspace
 from autobyteus.agent.tool_invocation import ToolInvocation
 # LLMConfig is no longer needed here
@@ -15,22 +17,23 @@ from autobyteus.agent.tool_invocation import ToolInvocation
 from autobyteus.task_management.todo_list import ToDoList
 
 if TYPE_CHECKING:
-    from autobyteus.agent.phases import AgentPhaseManager 
+    from autobyteus.agent.status.manager import AgentStatusManager 
     from autobyteus.tools.base_tool import BaseTool 
     from autobyteus.agent.tool_invocation import ToolInvocationTurn
+    from autobyteus.memory.memory_manager import MemoryManager
+    from autobyteus.memory.restore.working_context_snapshot_bootstrapper import WorkingContextSnapshotBootstrapOptions
 
 logger = logging.getLogger(__name__)
 
 class AgentRuntimeState:
     """
     Encapsulates the dynamic, stateful data of an agent instance.
-    Input event queues are initialized by the AgentWorker via a bootstrap step.
+    Input event queues are initialized by the AgentWorker during minimal runtime init.
     Output data is now handled by emitting events via AgentExternalEventNotifier.
     """
     def __init__(self,
                  agent_id: str, 
                  workspace: Optional[BaseAgentWorkspace] = None,
-                 conversation_history: Optional[List[Dict[str, Any]]] = None,
                  custom_data: Optional[Dict[str, Any]] = None):
         if not agent_id or not isinstance(agent_id, str):
             raise ValueError("AgentRuntimeState requires a non-empty string 'agent_id'.")
@@ -38,15 +41,16 @@ class AgentRuntimeState:
             raise TypeError(f"AgentRuntimeState 'workspace' must be a BaseAgentWorkspace or None. Got {type(workspace)}")
 
         self.agent_id: str = agent_id 
-        self.current_phase: AgentOperationalPhase = AgentOperationalPhase.UNINITIALIZED 
+        self.current_status: AgentStatus = AgentStatus.UNINITIALIZED 
         self.llm_instance: Optional[BaseLLM] = None  
         self.tool_instances: Optional[Dict[str, 'BaseTool']] = None 
         
         self.input_event_queues: Optional[AgentInputEventQueueManager] = None 
+        self.event_store: Optional[AgentEventStore] = None
+        self.status_deriver: Optional[AgentStatusDeriver] = None
         # REMOVED: self.output_data_queues attribute
         
         self.workspace: Optional[BaseAgentWorkspace] = workspace
-        self.conversation_history: List[Dict[str, Any]] = conversation_history or []
         self.pending_tool_approvals: Dict[str, ToolInvocation] = {}
         self.custom_data: Dict[str, Any] = custom_data or {}
         
@@ -55,20 +59,18 @@ class AgentRuntimeState:
         
         # NEW: State for the agent's personal ToDoList
         self.todo_list: Optional[ToDoList] = None
+
+        # NEW: Memory manager and active turn tracking
+        self.memory_manager: Optional["MemoryManager"] = None
+        self.active_turn_id: Optional[str] = None
+        self.restore_options: Optional["WorkingContextSnapshotBootstrapOptions"] = None
         
         self.processed_system_prompt: Optional[str] = None
         # self.final_llm_config_for_creation removed
         
-        self.phase_manager_ref: Optional['AgentPhaseManager'] = None 
+        self.status_manager_ref: Optional['AgentStatusManager'] = None 
          
-        logger.info(f"AgentRuntimeState initialized for agent_id '{self.agent_id}'. Initial phase: {self.current_phase.value}. Workspace linked. InputQueues pending initialization. Output data via notifier.")
-
-    def add_message_to_history(self, message: Dict[str, Any]) -> None:
-        if not isinstance(message, dict) or "role" not in message: # pragma: no cover
-            logger.warning(f"Attempted to add malformed message to history for agent '{self.agent_id}': {message}")
-            return
-        self.conversation_history.append(message)
-        logger.debug(f"Message added to history for agent '{self.agent_id}': role={message['role']}")
+        logger.info(f"AgentRuntimeState initialized for agent_id '{self.agent_id}'. Initial status: {self.current_status.value}. Workspace linked. InputQueues pending initialization. Output data via notifier.")
 
     def store_pending_tool_invocation(self, invocation: ToolInvocation) -> None:
         if not isinstance(invocation, ToolInvocation) or not invocation.id: # pragma: no cover
@@ -86,14 +88,14 @@ class AgentRuntimeState:
         return invocation
     
     def __repr__(self) -> str:
-        phase_repr = self.current_phase.value
+        # status_repr removed or renamed
         llm_status = "Initialized" if self.llm_instance else "Not Initialized"
         tools_status = f"{len(self.tool_instances)} Initialized" if self.tool_instances is not None else "Not Initialized"
         input_queues_status = "Initialized" if self.input_event_queues else "Not Initialized"
         # REMOVED output_queues_status from repr
         active_turn_status = "Active" if self.active_multi_tool_call_turn else "Inactive"
-        return (f"AgentRuntimeState(agent_id='{self.agent_id}', current_phase='{phase_repr}', "
+        return (f"AgentRuntimeState(agent_id='{self.agent_id}', current_status='{self.current_status.value}', "
                 f"llm_status='{llm_status}', tools_status='{tools_status}', "
                 f"input_queues_status='{input_queues_status}', "
-                f"pending_approvals={len(self.pending_tool_approvals)}, history_len={len(self.conversation_history)}, "
+                f"pending_approvals={len(self.pending_tool_approvals)}, "
                 f"multi_tool_call_turn='{active_turn_status}')")

autobyteus/agent/events/__init__.py

@@ -5,18 +5,25 @@ Also includes the WorkerEventDispatcher for routing events within an agent's wor
 """
 from .agent_input_event_queue_manager import AgentInputEventQueueManager
 from .worker_event_dispatcher import WorkerEventDispatcher 
+from .event_store import AgentEventStore, EventEnvelope
 
 from .agent_events import (
     BaseEvent,
     # Categorical Base Events
     LifecycleEvent,
     AgentProcessingEvent,
-    # Agent Phase-Specific Base Events
+    # Agent Status-Specific Base Events
     AgentOperationalEvent,
     # Specific Lifecycle Events
     AgentReadyEvent, 
     AgentStoppedEvent,
     AgentErrorEvent,
+    AgentIdleEvent,
+    ShutdownRequestedEvent,
+    BootstrapStartedEvent,
+    BootstrapStepRequestedEvent,
+    BootstrapStepCompletedEvent,
+    BootstrapCompletedEvent,
     # Regular Agent Processing Events
     UserMessageReceivedEvent, 
     InterAgentMessageReceivedEvent, 
@@ -33,6 +40,8 @@ from .agent_events import (
 __all__ = [
     "AgentInputEventQueueManager", 
     "WorkerEventDispatcher", 
+    "AgentEventStore",
+    "EventEnvelope",
     "BaseEvent",
     "LifecycleEvent",
     "AgentProcessingEvent",
@@ -40,6 +49,12 @@ __all__ = [
     "AgentReadyEvent", 
     "AgentStoppedEvent",
     "AgentErrorEvent",
+    "AgentIdleEvent",
+    "ShutdownRequestedEvent",
+    "BootstrapStartedEvent",
+    "BootstrapStepRequestedEvent",
+    "BootstrapStepCompletedEvent",
+    "BootstrapCompletedEvent",
     "UserMessageReceivedEvent",
     "InterAgentMessageReceivedEvent",
     "LLMUserMessageReadyEvent", 

autobyteus/agent/events/agent_events.py

@@ -1,10 +1,12 @@
+
 # file: autobyteus/autobyteus/agent/events/agent_events.py
 from dataclasses import dataclass, field 
 from typing import Any, Dict, Optional
 
 from autobyteus.agent.message.agent_input_user_message import AgentInputUserMessage 
-from autobyteus.agent.tool_invocation import ToolInvocation 
 from autobyteus.agent.message.inter_agent_message import InterAgentMessage
+from autobyteus.agent.status.status_enum import AgentStatus
+from autobyteus.agent.tool_invocation import ToolInvocation
 from autobyteus.llm.user_message import LLMUserMessage 
 from autobyteus.llm.utils.response_types import CompleteResponse
 
@@ -25,10 +27,10 @@ class AgentProcessingEvent(BaseEvent):
     """Base class for events related to the agent's internal data processing and task execution logic."""
 
 
-# --- Agent Operational Phase Events ---
+# --- Agent Operational Status Events ---
 @dataclass
 class AgentOperationalEvent(AgentProcessingEvent): 
-    """Base class for events that occur during the agent's active operational phase (post-preparation)."""
+    """Base class for events that occur during the agent's active operational status (post-preparation)."""
     pass
 
 
@@ -50,6 +52,42 @@ class AgentErrorEvent(LifecycleEvent):
     error_message: str
     exception_details: Optional[str] = None 
 
+@dataclass
+class AgentIdleEvent(LifecycleEvent):
+    """Event indicating the agent has completed a processing cycle and is idle."""
+    pass
+
+@dataclass
+class ShutdownRequestedEvent(LifecycleEvent):
+    """Event indicating a shutdown has been requested."""
+    pass
+
+# --- Bootstrap Lifecycle Events ---
+
+@dataclass
+class BootstrapStartedEvent(LifecycleEvent):
+    """Event indicating the bootstrap orchestration has begun."""
+    pass
+
+@dataclass
+class BootstrapStepRequestedEvent(LifecycleEvent):
+    """Event requesting execution of a specific bootstrap step."""
+    step_index: int
+
+@dataclass
+class BootstrapStepCompletedEvent(LifecycleEvent):
+    """Event indicating a bootstrap step has completed."""
+    step_index: int
+    step_name: str
+    success: bool
+    error_message: Optional[str] = None
+
+@dataclass
+class BootstrapCompletedEvent(LifecycleEvent):
+    """Event indicating the bootstrap sequence has completed."""
+    success: bool
+    error_message: Optional[str] = None
+
 
 # --- Regular Agent Processing Events (now Operational) ---
 
@@ -85,7 +123,9 @@ class ToolResultEvent(AgentOperationalEvent):
     tool_name: str
     result: Any
     tool_invocation_id: Optional[str] = None 
+    turn_id: Optional[str] = None
     error: Optional[str] = None
+    tool_args: Optional[Dict[str, Any]] = None # Carries original arguments for internal processing (e.g. artifacts)
 
 @dataclass
 class ToolExecutionApprovalEvent(AgentOperationalEvent): 

autobyteus/agent/events/agent_input_event_queue_manager.py

@@ -2,6 +2,7 @@
 import asyncio
 import logging
 from typing import Any, AsyncIterator, Union, Tuple, Optional, List, TYPE_CHECKING, Dict, Set
+from collections import deque
 
 # Import specific event types for queue annotations where possible
 if TYPE_CHECKING:
@@ -20,7 +21,9 @@ logger = logging.getLogger(__name__)
 class AgentInputEventQueueManager:
     """
     Manages asyncio.Queue instances for events consumed by the AgentRuntime's
-    main event loop. This class focuses solely on queues for internal agent processing.
+    main event loop. Uses per-queue ready buffers plus a deterministic priority
+    order to avoid requeue-induced reordering when multiple queues are ready at
+    the same time.
     """
     def __init__(self, queue_size: int = 0):
         self.user_message_input_queue: asyncio.Queue['UserMessageReceivedEvent'] = asyncio.Queue(maxsize=queue_size)
@@ -38,6 +41,21 @@ class AgentInputEventQueueManager:
             ("tool_execution_approval_queue", self.tool_execution_approval_queue),
             ("internal_system_event_queue", self.internal_system_event_queue),
         ]
+
+        # Buffer of ready items per queue to avoid requeue-induced reordering.
+        self._ready_buffers: Dict[str, deque[Any]] = {
+            name: deque() for name, _ in self._input_queues
+        }
+
+        # Deterministic priority order when multiple queues are ready.
+        self._queue_priority: List[str] = [
+            "user_message_input_queue",
+            "inter_agent_message_input_queue",
+            "tool_invocation_request_queue",
+            "tool_result_input_queue",
+            "tool_execution_approval_queue",
+            "internal_system_event_queue",
+        ]
         logger.info("AgentInputEventQueueManager initialized.")
 
     async def enqueue_user_message(self, event: 'UserMessageReceivedEvent') -> None:
@@ -65,7 +83,27 @@ class AgentInputEventQueueManager:
         logger.debug(f"Enqueued internal system event: {type(event).__name__}")
 
     async def get_next_input_event(self) -> Optional[Tuple[str, 'BaseEvent']]: # type: ignore[type-var]
-        # Logger messages will be updated in subsequent steps if needed
+        """
+        Returns the next available event along with its originating queue name.
+
+        Algorithm:
+        1. Serve any buffered items first (buffers keep FIFO per queue).
+        2. If none buffered, await one get() per queue with FIRST_COMPLETED,
+           buffer all completed results (no requeue to the tail), cancel the rest.
+        3. Return the highest-priority buffered item.
+
+        This preserves intra-queue order and avoids the previous bug where
+        re-inserting a ready item to the queue tail could invert tool call order.
+        """
+        # 1) Serve any buffered items first (deterministic priority).
+        for qname in self._queue_priority:
+            buf = self._ready_buffers.get(qname)
+            if buf and buf:
+                event = buf.popleft()
+                logger.debug(f"get_next_input_event: Returning buffered event from {qname}: {type(event).__name__}")
+                return (qname, event)
+
+        # 2) No buffered items; proceed to gather one from live queues.
         logger.debug(f"get_next_input_event: Checking queue sizes before creating tasks...")
         for name, q_obj in self._input_queues:
             if q_obj is not None: # pragma: no cover
@@ -82,9 +120,6 @@ class AgentInputEventQueueManager:
         
         logger.debug(f"get_next_input_event: Created {len(created_tasks)} tasks for queues: {[t.get_name() for t in created_tasks]}. Awaiting asyncio.wait...")
         
-        event_tuple: Optional[Tuple[str, 'BaseEvent']] = None # type: ignore[type-var]
-        done_tasks_from_wait: Set[asyncio.Task] = set()
-        
         try:
             done_tasks_from_wait, pending_tasks_from_wait = await asyncio.wait(
                 created_tasks, return_when=asyncio.FIRST_COMPLETED
@@ -92,37 +127,27 @@ class AgentInputEventQueueManager:
             
             logger.debug(f"get_next_input_event: asyncio.wait returned. Done tasks: {len(done_tasks_from_wait)}, Pending tasks: {len(pending_tasks_from_wait)}.")
             
-            if done_tasks_from_wait: # pragma: no branch
-                for i, task_in_done in enumerate(done_tasks_from_wait): # pragma: no cover
-                    logger.debug(f"get_next_input_event: Processing done task #{i+1} (name: {task_in_done.get_name()})")
-            
+            # Collect all done results into buffers without requeueing
             for task in done_tasks_from_wait:
                 queue_name = task.get_name()
                 try:
-                    event_result: Any = task.result() 
+                    event_result: Any = task.result()
                     logger.debug(f"get_next_input_event: Task for queue '{queue_name}' completed. Result type: {type(event_result).__name__}, Result: {str(event_result)[:100]}")
                     
-                    # Avoid circular import for BaseEvent, assuming it's correctly imported in TYPE_CHECKING context
-                    from autobyteus.agent.events.agent_events import BaseEvent as AgentBaseEvent 
+                    from autobyteus.agent.events.agent_events import BaseEvent as AgentBaseEvent
                     if isinstance(event_result, AgentBaseEvent):
-                        event: 'BaseEvent' = event_result # type: ignore[type-var]
-                        if event_tuple is None: 
-                            event_tuple = (queue_name, event)
-                            logger.debug(f"get_next_input_event: Dequeued event from {queue_name}: {type(event).__name__}")
-                        else: # pragma: no cover
-                            original_queue = next((q for n, q in self._input_queues if n == queue_name), None)
-                            if original_queue:
-                                original_queue.put_nowait(event) 
-                                logger.warning(f"get_next_input_event: Re-queued event from {queue_name} (type {type(event).__name__}) as another event was processed first in the same wait cycle.")
+                        self._ready_buffers[queue_name].append(event_result)
+                        logger.debug(f"get_next_input_event: Buffered event from {queue_name}: {type(event_result).__name__}")
                     else: # pragma: no cover
                         logger.error(f"get_next_input_event: Dequeued item from {queue_name} is not a BaseEvent subclass: {type(event_result)}. Event: {event_result!r}")
 
                 except asyncio.CancelledError: # pragma: no cover
-                     logger.info(f"get_next_input_event: Task for queue {queue_name} (from done set) was cancelled during result processing.")
+                    logger.info(f"get_next_input_event: Task for queue {queue_name} (from done set) was cancelled during result processing.")
                 except Exception as e:  # pragma: no cover
                     logger.error(f"get_next_input_event: Error processing result from task for queue {queue_name} (from done set): {e}", exc_info=True)
             
-            if pending_tasks_from_wait: # pragma: no branch
+            # Cancel pending tasks
+            if pending_tasks_from_wait:
                 logger.debug(f"get_next_input_event: Cancelling {len(pending_tasks_from_wait)} pending tasks from asyncio.wait.")
                 for task_in_pending in pending_tasks_from_wait: # pragma: no cover
                     if not task_in_pending.done():
@@ -160,9 +185,37 @@ class AgentInputEventQueueManager:
             
             logger.debug(f"get_next_input_event: Finished finally block task cleanup.")
 
-        if event_tuple:
-            logger.debug(f"get_next_input_event: Returning event_tuple: {type(event_tuple[1]).__name__ if event_tuple else 'None'}")
-        return event_tuple
+        # After buffering, return the highest-priority ready item (if any)
+        for qname in self._queue_priority:
+            buf = self._ready_buffers.get(qname)
+            if buf and buf:
+                event = buf.popleft()
+                logger.debug(f"get_next_input_event: Returning buffered event from {qname}: {type(event).__name__}")
+                return (qname, event)
+
+        logger.debug("get_next_input_event: No events available after buffering.")
+        return None
+
+    async def get_next_internal_event(self) -> Optional[Tuple[str, 'BaseEvent']]: # type: ignore[type-var]
+        """
+        Returns the next available internal system event only.
+        Intended for bootstrapping phases where non-internal queues should be gated.
+        """
+        qname = "internal_system_event_queue"
+        buf = self._ready_buffers.get(qname)
+        if buf and buf:
+            event = buf.popleft()
+            logger.debug(f"get_next_internal_event: Returning buffered event from {qname}: {type(event).__name__}")
+            return (qname, event)
+
+        event_result: Any = await self.internal_system_event_queue.get()
+        from autobyteus.agent.events.agent_events import BaseEvent as AgentBaseEvent
+        if isinstance(event_result, AgentBaseEvent):
+            logger.debug(f"get_next_internal_event: Dequeued event from {qname}: {type(event_result).__name__}")
+            return (qname, event_result)
+
+        logger.error(f"get_next_internal_event: Dequeued item is not a BaseEvent subclass: {type(event_result)}. Event: {event_result!r}")
+        return None
 
     def log_remaining_items_at_shutdown(self): # pragma: no cover
         """Logs remaining items in input queues, typically called during shutdown."""

autobyteus/agent/events/event_store.py

@@ -0,0 +1,57 @@
+# file: autobyteus/autobyteus/agent/events/event_store.py
+from __future__ import annotations
+
+import logging
+import time
+import uuid
+from dataclasses import dataclass
+from typing import List, Optional
+
+from autobyteus.agent.events.agent_events import BaseEvent
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass(frozen=True)
+class EventEnvelope:
+    event_id: str
+    event_type: str
+    timestamp: float
+    agent_id: str
+    event: BaseEvent
+    correlation_id: Optional[str] = None
+    caused_by_event_id: Optional[str] = None
+    sequence: int = 0
+
+
+class AgentEventStore:
+    """
+    Simple in-memory event store for agent events.
+    """
+    def __init__(self, agent_id: str):
+        self._agent_id = agent_id
+        self._events: List[EventEnvelope] = []
+        self._sequence: int = 0
+        logger.debug(f"AgentEventStore initialized for agent_id '{agent_id}'.")
+
+    def append(self,
+               event: BaseEvent,
+               correlation_id: Optional[str] = None,
+               caused_by_event_id: Optional[str] = None) -> EventEnvelope:
+        envelope = EventEnvelope(
+            event_id=str(uuid.uuid4()),
+            event_type=type(event).__name__,
+            timestamp=time.time(),
+            agent_id=self._agent_id,
+            event=event,
+            correlation_id=correlation_id,
+            caused_by_event_id=caused_by_event_id,
+            sequence=self._sequence,
+        )
+        self._sequence += 1
+        self._events.append(envelope)
+        logger.debug(f"Appended event '{envelope.event_type}' to store for agent '{self._agent_id}'.")
+        return envelope
+
+    def all_events(self) -> List[EventEnvelope]:
+        return list(self._events)

autobyteus/agent/events/notifiers.py

@@ -4,7 +4,7 @@ from typing import Optional, Dict, Any, TYPE_CHECKING, List
 
 from autobyteus.events.event_emitter import EventEmitter
 from autobyteus.events.event_types import EventType 
-from autobyteus.agent.phases import AgentOperationalPhase
+from autobyteus.agent.status.status_enum import AgentStatus
 
 if TYPE_CHECKING:
     from autobyteus.llm.utils.response_types import ChunkResponse, CompleteResponse 
@@ -13,7 +13,7 @@ logger = logging.getLogger(__name__)
 
 class AgentExternalEventNotifier(EventEmitter):
     """
-    Responsible for emitting external events related to agent phase transitions
+    Responsible for emitting external events related to agent status updates
     and data outputs.
     """
     def __init__(self, agent_id: str):
@@ -31,75 +31,73 @@ class AgentExternalEventNotifier(EventEmitter):
             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)
+        # Reduce log level for high-frequency events like streaming chunks/segments
+        if event_type in {EventType.AGENT_DATA_ASSISTANT_CHUNK, EventType.AGENT_DATA_SEGMENT_EVENT}:
+            summary = self._summarize_payload(event_type, payload_content)
+            if summary:
+                logger.debug(f"{log_message} | {summary}")
+            else:
+                logger.debug(log_message)
         else:
             logger.info(log_message)
 
-
-    def _emit_phase_change(self, 
-                           event_type: EventType, 
-                           new_phase: AgentOperationalPhase,
-                           old_phase: Optional[AgentOperationalPhase] = None, 
-                           additional_data: Optional[Dict[str, Any]] = None):
-        phase_payload_dict = { 
-            "new_phase": new_phase.value, 
-            "old_phase": old_phase.value if old_phase else None,
+    def _summarize_payload(self, event_type: EventType, payload_content: Optional[Any]) -> Optional[str]:
+        """Return a compact, non-sensitive payload summary for debug logs."""
+        if payload_content is None:
+            return None
+
+        if event_type == EventType.AGENT_DATA_SEGMENT_EVENT and isinstance(payload_content, dict):
+            seg_type = payload_content.get("segment_type")
+            seg_id = payload_content.get("segment_id")
+            seg_event_type = payload_content.get("type")
+            payload = payload_content.get("payload") or {}
+            summary_parts = [f"segment_id={seg_id}", f"segment_type={seg_type}", f"event_type={seg_event_type}"]
+            if isinstance(payload, dict):
+                if "delta" in payload:
+                    delta = payload.get("delta", "")
+                    summary_parts.append(f"delta_len={len(str(delta))}")
+                if "metadata" in payload and isinstance(payload.get("metadata"), dict):
+                    meta_keys = list(payload.get("metadata").keys())
+                    if meta_keys:
+                        summary_parts.append(f"metadata_keys={meta_keys}")
+            return " ".join(summary_parts)
+
+        if event_type == EventType.AGENT_DATA_ASSISTANT_CHUNK and hasattr(payload_content, "content"):
+            content = getattr(payload_content, "content", "") or ""
+            reasoning = getattr(payload_content, "reasoning", "") or ""
+            return f"content_len={len(str(content))} reasoning_len={len(str(reasoning))}"
+
+        return None
+
+
+    def _emit_status_update(self,
+                            new_status: AgentStatus,
+                            old_status: Optional[AgentStatus] = None,
+                            additional_data: Optional[Dict[str, Any]] = None):
+        status_payload_dict = { 
+            "new_status": new_status.value, 
+            "old_status": old_status.value if old_status else None,
         }
         if additional_data: 
-            phase_payload_dict.update(additional_data)
-        self._emit_event(event_type, payload_content=phase_payload_dict) 
-
-    def notify_phase_uninitialized_entered(self, old_phase: Optional[AgentOperationalPhase]):
-        self._emit_phase_change(EventType.AGENT_PHASE_UNINITIALIZED_ENTERED, AgentOperationalPhase.UNINITIALIZED, old_phase)
-
-    def notify_phase_bootstrapping_started(self, old_phase: Optional[AgentOperationalPhase]):
-        self._emit_phase_change(EventType.AGENT_PHASE_BOOTSTRAPPING_STARTED, AgentOperationalPhase.BOOTSTRAPPING, old_phase)
-
-    def notify_phase_idle_entered(self, old_phase: Optional[AgentOperationalPhase]):
-        self._emit_phase_change(EventType.AGENT_PHASE_IDLE_ENTERED, AgentOperationalPhase.IDLE, old_phase)
-
-    def notify_phase_processing_user_input_started(self, old_phase: Optional[AgentOperationalPhase], trigger_info: Optional[str] = None):
-        data = {"trigger": trigger_info} if trigger_info else {}
-        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)
-    def notify_phase_processing_tool_result_started(self, old_phase: Optional[AgentOperationalPhase], tool_name: str):
-        data = {"tool_name": tool_name}
-        self._emit_phase_change(EventType.AGENT_PHASE_PROCESSING_TOOL_RESULT_STARTED, AgentOperationalPhase.PROCESSING_TOOL_RESULT, old_phase, additional_data=data)
-    def notify_phase_shutting_down_started(self, old_phase: Optional[AgentOperationalPhase]):
-        self._emit_phase_change(EventType.AGENT_PHASE_SHUTTING_DOWN_STARTED, AgentOperationalPhase.SHUTTING_DOWN, old_phase)
-    def notify_phase_shutdown_completed(self, old_phase: Optional[AgentOperationalPhase]):
-        self._emit_phase_change(EventType.AGENT_PHASE_SHUTDOWN_COMPLETED, AgentOperationalPhase.SHUTDOWN_COMPLETE, old_phase)
-    def notify_phase_error_entered(self, old_phase: Optional[AgentOperationalPhase], error_message: str, error_details: Optional[str] = None):
-        data = {"error_message": error_message, "error_details": error_details}
-        self._emit_phase_change(EventType.AGENT_PHASE_ERROR_ENTERED, AgentOperationalPhase.ERROR, old_phase, additional_data=data)
+            status_payload_dict.update(additional_data)
+        self._emit_event(EventType.AGENT_STATUS_UPDATED, payload_content=status_payload_dict)
+
+    def notify_status_updated(self,
+                              new_status: AgentStatus,
+                              old_status: Optional[AgentStatus] = None,
+                              additional_data: Optional[Dict[str, Any]] = None):
+        self._emit_status_update(new_status, old_status, additional_data)
 
     def notify_agent_data_assistant_chunk(self, chunk: 'ChunkResponse'): 
         self._emit_event(EventType.AGENT_DATA_ASSISTANT_CHUNK, payload_content=chunk) 
 
-    def notify_agent_data_assistant_chunk_stream_end(self): 
-        self._emit_event(EventType.AGENT_DATA_ASSISTANT_CHUNK_STREAM_END) 
-
     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_segment_event(self, event_dict: Dict[str, Any]):
+        """Notify a streaming parser segment event (START, CONTENT, END)."""
+        self._emit_event(EventType.AGENT_DATA_SEGMENT_EVENT, payload_content=event_dict)
+
     def notify_agent_data_tool_log(self, log_data: Dict[str, Any]): 
         self._emit_event(EventType.AGENT_DATA_TOOL_LOG, payload_content=log_data) 
     
@@ -117,6 +115,10 @@ class AgentExternalEventNotifier(EventEmitter):
         """Notifies that the agent has received a system-generated task notification."""
         self._emit_event(EventType.AGENT_DATA_SYSTEM_TASK_NOTIFICATION_RECEIVED, payload_content=notification_data)
 
+    def notify_agent_data_inter_agent_message_received(self, message_data: Dict[str, Any]):
+        """Notifies that the agent has received a message from another agent."""
+        self._emit_event(EventType.AGENT_DATA_INTER_AGENT_MESSAGE_RECEIVED, payload_content=message_data)
+
     def notify_agent_data_todo_list_updated(self, todo_list: List[Dict[str, Any]]):
         """Notifies that the agent's ToDo list has been updated."""
         self._emit_event(EventType.AGENT_DATA_TODO_LIST_UPDATED, payload_content={"todos": todo_list})
@@ -128,3 +130,11 @@ class AgentExternalEventNotifier(EventEmitter):
             "details": error_details
         }
         self._emit_event(EventType.AGENT_ERROR_OUTPUT_GENERATION, payload_content=payload_dict)
+
+    def notify_agent_artifact_persisted(self, artifact_data: Dict[str, Any]):
+        """Notifies that an artifact has been successfully persisted to the database."""
+        self._emit_event(EventType.AGENT_ARTIFACT_PERSISTED, payload_content=artifact_data)
+
+    def notify_agent_artifact_updated(self, artifact_data: Dict[str, Any]):
+        """Notifies that an artifact has been updated (e.g., via patch_file)."""
+        self._emit_event(EventType.AGENT_ARTIFACT_UPDATED, payload_content=artifact_data)