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

autobyteus/agent/handlers/llm_user_message_ready_event_handler.py

@@ -1,13 +1,21 @@
 # file: autobyteus/autobyteus/agent/handlers/llm_user_message_ready_event_handler.py
 import logging
 import traceback
-from typing import TYPE_CHECKING, cast, Optional, List
+import uuid
+from typing import TYPE_CHECKING, Optional, List
 
 from autobyteus.agent.handlers.base_event_handler import AgentEventHandler
-from autobyteus.agent.events import LLMUserMessageReadyEvent, LLMCompleteResponseReceivedEvent 
+from autobyteus.agent.events import LLMUserMessageReadyEvent, LLMCompleteResponseReceivedEvent, PendingToolInvocationEvent 
 from autobyteus.llm.user_message import LLMUserMessage
 from autobyteus.llm.utils.response_types import ChunkResponse, CompleteResponse
 from autobyteus.llm.utils.token_usage import TokenUsage
+from autobyteus.agent.streaming.streaming_response_handler import StreamingResponseHandler
+from autobyteus.agent.streaming.streaming_handler_factory import StreamingResponseHandlerFactory
+from autobyteus.agent.streaming.parser.events import SegmentEvent, SegmentType
+from autobyteus.agent.tool_invocation import ToolInvocationTurn
+from autobyteus.agent.llm_request_assembler import LLMRequestAssembler
+from autobyteus.agent.token_budget import apply_compaction_policy, resolve_token_budget
+from autobyteus.llm.prompt_renderers.openai_chat_renderer import OpenAIChatRenderer
 
 if TYPE_CHECKING:
     from autobyteus.agent.context import AgentContext
@@ -18,9 +26,8 @@ logger = logging.getLogger(__name__)
 class LLMUserMessageReadyEventHandler(AgentEventHandler): 
     """
     Handles LLMUserMessageReadyEvents by sending the prepared LLMUserMessage 
-    to the LLM, emitting AGENT_DATA_ASSISTANT_CHUNK events via the notifier
-    for each chunk, emitting AGENT_DATA_ASSISTANT_CHUNK_STREAM_END upon completion,
-    and then enqueuing an LLMCompleteResponseReceivedEvent with the full aggregated response.
+    to the LLM, passing the stream through StreamingResponseHandler for safe parsing,
+    emitting filtered chunks via the notifier, and finally enqueuing the complete response.
     """
 
     def __init__(self):
@@ -37,8 +44,8 @@ class LLMUserMessageReadyEventHandler(AgentEventHandler):
         if context.state.llm_instance is None: 
             error_msg = f"Agent '{agent_id}' received LLMUserMessageReadyEvent but LLM instance is not yet initialized."
             logger.critical(error_msg)
-            if context.phase_manager and context.phase_manager.notifier:
-                context.phase_manager.notifier.notify_agent_error_output_generation( # USE RENAMED METHOD
+            if context.status_manager and context.status_manager.notifier:
+                context.status_manager.notifier.notify_agent_error_output_generation(
                     error_source="LLMUserMessageReadyEventHandler.pre_llm_check",
                     error_message=error_msg
                 )
@@ -48,8 +55,13 @@ class LLMUserMessageReadyEventHandler(AgentEventHandler):
         logger.info(f"Agent '{agent_id}' handling LLMUserMessageReadyEvent: '{llm_user_message.content}'") 
         logger.debug(f"Agent '{agent_id}' preparing to send full message to LLM:\n---\n{llm_user_message.content}\n---")
         
-        context.state.add_message_to_history({"role": "user", "content": llm_user_message.content})
+        memory_manager = getattr(context.state, "memory_manager", None)
+        active_turn_id = getattr(context.state, "active_turn_id", None)
+        if memory_manager and not active_turn_id:
+            active_turn_id = memory_manager.start_turn()
+            context.state.active_turn_id = active_turn_id
 
+        # Initialize aggregators
         complete_response_text = ""
         complete_reasoning_text = ""
         token_usage: Optional[TokenUsage] = None
@@ -57,66 +69,192 @@ class LLMUserMessageReadyEventHandler(AgentEventHandler):
         complete_audio_urls: List[str] = []
         complete_video_urls: List[str] = []
         
+        # Get notifier for emitting events
         notifier: Optional['AgentExternalEventNotifier'] = None
-        if context.phase_manager:
-            notifier = context.phase_manager.notifier
+        if context.status_manager:
+            notifier = context.status_manager.notifier
         
         if not notifier: # pragma: no cover
             logger.error(f"Agent '{agent_id}': Notifier not available in LLMUserMessageReadyEventHandler. Cannot emit chunk events.")
 
+        # Callback for segment events from streaming parser
+        def emit_segment_event(event: SegmentEvent):
+            if notifier:
+                try:
+                    notifier.notify_agent_segment_event(event.to_dict())
+                except Exception as e:
+                    logger.error(f"Agent '{agent_id}': Error notifying segment event: {e}", exc_info=True)
+
+        # Collect tool names from agent state/config
+        tool_names: List[str] = []
+        if context.state.tool_instances:
+            tool_names = list(context.state.tool_instances.keys())
+        elif context.config.tools:
+            for tool in context.config.tools:
+                if isinstance(tool, str):
+                    tool_names.append(tool)
+                elif hasattr(tool, "get_name"):
+                    try:
+                        tool_names.append(tool.get_name())
+                    except Exception:  # pragma: no cover - defensive
+                        logger.warning(
+                            "Agent '%s': Failed to resolve tool name from %s.",
+                            agent_id,
+                            type(tool),
+                        )
+                else:  # pragma: no cover - defensive
+                    logger.warning(
+                        "Agent '%s': Unsupported tool entry in config: %s.",
+                        agent_id,
+                        type(tool),
+                    )
+        
+        # Get provider from LLM instance
+        provider = context.state.llm_instance.model.provider if context.state.llm_instance else None
+
+        # Create streaming handler via factory (all configuration encapsulated)
+        handler_result = StreamingResponseHandlerFactory.create(
+            tool_names=tool_names,
+            provider=provider,
+            on_segment_event=emit_segment_event,
+            agent_id=agent_id,
+        )
+        streaming_handler = handler_result.handler
+        
+        logger.info(
+            "Agent '%s': Streaming handler selected: %s",
+            agent_id,
+            streaming_handler.__class__.__name__,
+        )
+
+        # Prepare arguments for stream_user_message
+        stream_kwargs = {}
+        if handler_result.tool_schemas:
+            stream_kwargs["tools"] = handler_result.tool_schemas
+            logger.info(
+                "Agent '%s': Passing %d tool schemas to LLM API (Provider: %s)",
+                agent_id,
+                len(handler_result.tool_schemas),
+                provider,
+            )
+
+        if not memory_manager:
+            raise RuntimeError(f"Agent '{agent_id}' requires a memory manager to assemble LLM requests.")
+
+        llm_config = getattr(context.state.llm_instance, "config", None)
+        llm_model = getattr(context.state.llm_instance, "model", None)
+
+        renderer = getattr(context.state.llm_instance, "_renderer", None) or OpenAIChatRenderer()
+        assembler = LLMRequestAssembler(
+            memory_manager=memory_manager,
+            renderer=renderer,
+        )
+        system_prompt = (
+            context.state.processed_system_prompt
+            or context.state.llm_instance.config.system_message
+        )
+        request = await assembler.prepare_request(
+            processed_user_input=llm_user_message,
+            current_turn_id=active_turn_id,
+            system_prompt=system_prompt,
+        )
+
+        # State for manual reasoning parts (since they might come from outside the parser)
+        segment_id_prefix = f"turn_{uuid.uuid4().hex}:"
+        current_reasoning_part_id = None
+
         try:
-            async for chunk_response in context.state.llm_instance.stream_user_message(llm_user_message):
+            async for chunk_response in context.state.llm_instance.stream_messages(
+                request.messages,
+                rendered_payload=request.rendered_payload,
+                **stream_kwargs,
+            ):
                 if not isinstance(chunk_response, ChunkResponse): 
                     logger.warning(f"Agent '{agent_id}' received unexpected chunk type: {type(chunk_response)} during LLM stream. Expected ChunkResponse.")
                     continue
 
+                # Aggregate full raw content
                 if chunk_response.content:
                     complete_response_text += chunk_response.content
                 if chunk_response.reasoning:
                     complete_reasoning_text += chunk_response.reasoning
 
+                # Collect usage and media from final chunks
                 if chunk_response.is_complete:
                     if chunk_response.usage:
                         token_usage = chunk_response.usage
                         logger.debug(f"Agent '{agent_id}' received final chunk with token usage: {token_usage}")
                     if chunk_response.image_urls:
                         complete_image_urls.extend(chunk_response.image_urls)
-                        logger.debug(f"Agent '{agent_id}' received final chunk with {len(chunk_response.image_urls)} image URLs.")
                     if chunk_response.audio_urls:
                         complete_audio_urls.extend(chunk_response.audio_urls)
-                        logger.debug(f"Agent '{agent_id}' received final chunk with {len(chunk_response.audio_urls)} audio URLs.")
                     if chunk_response.video_urls:
                         complete_video_urls.extend(chunk_response.video_urls)
-                        logger.debug(f"Agent '{agent_id}' received final chunk with {len(chunk_response.video_urls)} video URLs.")
 
-                if notifier:
-                    try:
-                        # The chunk object now contains both content and reasoning
-                        notifier.notify_agent_data_assistant_chunk(chunk_response) 
-                    except Exception as e_notify: 
-                         logger.error(f"Agent '{agent_id}': Error notifying assistant chunk generated: {e_notify}", exc_info=True)
-            
-            if notifier:
-                try:
-                    notifier.notify_agent_data_assistant_chunk_stream_end() 
-                except Exception as e_notify_end: 
-                    logger.error(f"Agent '{agent_id}': Error notifying assistant chunk stream end: {e_notify_end}", exc_info=True)
+                # Handle Reasoning (Manual Segment Management)
+                if chunk_response.reasoning:
+                    if current_reasoning_part_id is None:
+                        current_reasoning_part_id = f"{segment_id_prefix}reasoning_{uuid.uuid4().hex}"
+                        # Emit SEGMENT_START for reasoning
+                        start_event = SegmentEvent.start(
+                            segment_id=current_reasoning_part_id,
+                            segment_type=SegmentType.REASONING
+                        )
+                        emit_segment_event(start_event)
+                    
+                    # Emit SEGMENT_CONTENT for reasoning delta
+                    content_event = SegmentEvent.content(
+                        segment_id=current_reasoning_part_id,
+                        delta=chunk_response.reasoning
+                    )
+                    emit_segment_event(content_event)
 
-            logger.debug(f"Agent '{agent_id}' LLM stream completed. Full response length: {len(complete_response_text)}. Reasoning length: {len(complete_reasoning_text)}. Chunk stream ended event emitted.")
-            if complete_reasoning_text:
-                logger.debug(f"Agent '{agent_id}' aggregated full LLM reasoning:\n---\n{complete_reasoning_text}\n---")
-            logger.debug(f"Agent '{agent_id}' aggregated full LLM response:\n---\n{complete_response_text}\n---")
+                # Handle Content & Tool Calls (Through Handler)
+                # Pass the full ChunkResponse object to support both text and tool call streams
+                streaming_handler.feed(chunk_response)
+
+            # End of stream loop
 
+            # Finalize the stream parser to get any held-back content
+            streaming_handler.finalize()
+
+            # After finalization, enqueue any parsed tool invocations.
+            if tool_names:
+                tool_invocations = streaming_handler.get_all_invocations()
+                if tool_invocations:
+                    context.state.active_multi_tool_call_turn = ToolInvocationTurn(
+                        invocations=tool_invocations
+                    )
+                    logger.info(
+                        "Agent '%s': Parsed %d tool invocations from streaming parser.",
+                        agent_id,
+                        len(tool_invocations),
+                    )
+                    for invocation in tool_invocations:
+                        if active_turn_id and not invocation.turn_id:
+                            invocation.turn_id = active_turn_id
+                        if memory_manager:
+                            memory_manager.ingest_tool_intent(invocation, turn_id=active_turn_id)
+                        await context.input_event_queues.enqueue_tool_invocation_request(
+                            PendingToolInvocationEvent(tool_invocation=invocation)
+                        )
+
+            # Close any open reasoning segment
+            if current_reasoning_part_id:
+                end_event = SegmentEvent.end(segment_id=current_reasoning_part_id)
+                emit_segment_event(end_event)
+
+            logger.debug(f"Agent '{agent_id}' LLM stream completed. Full response length: {len(complete_response_text)}.")
+            if complete_reasoning_text:
+                logger.debug(f"Agent '{agent_id}' aggregated full LLM reasoning.")
+            
         except Exception as e:
             logger.error(f"Agent '{agent_id}' error during LLM stream: {e}", exc_info=True)
             error_message_for_output = f"Error processing your request with the LLM: {str(e)}"
             
             logger.warning(f"Agent '{agent_id}' LLM stream error. Error message for output: {error_message_for_output}")
-            context.state.add_message_to_history({"role": "assistant", "content": error_message_for_output, "is_error": True})
-            
             if notifier:
                 try:
-                    notifier.notify_agent_data_assistant_chunk_stream_end() 
                     notifier.notify_agent_error_output_generation( 
                         error_source="LLMUserMessageReadyEventHandler.stream_user_message",
                         error_message=error_message_for_output,
@@ -131,22 +269,10 @@ class LLMUserMessageReadyEventHandler(AgentEventHandler):
                 is_error=True 
             )
             await context.input_event_queues.enqueue_internal_system_event(llm_complete_event_on_error)
-            logger.info(f"Agent '{agent_id}' enqueued LLMCompleteResponseReceivedEvent with error details from LLMUserMessageReadyEventHandler.")
+            logger.info(f"Agent '{agent_id}' enqueued LLMCompleteResponseReceivedEvent with error details.")
             return 
 
-        # Add message to history with reasoning and multimodal data
-        history_entry = {"role": "assistant", "content": complete_response_text}
-        if complete_reasoning_text:
-            history_entry["reasoning"] = complete_reasoning_text
-        if complete_image_urls:
-            history_entry["image_urls"] = complete_image_urls
-        if complete_audio_urls:
-            history_entry["audio_urls"] = complete_audio_urls
-        if complete_video_urls:
-            history_entry["video_urls"] = complete_video_urls
-        context.state.add_message_to_history(history_entry)
-        
-        # Create complete response with reasoning and multimodal data
+        # Create complete response
         complete_response_obj = CompleteResponse(
             content=complete_response_text,
             reasoning=complete_reasoning_text,
@@ -155,9 +281,23 @@ class LLMUserMessageReadyEventHandler(AgentEventHandler):
             audio_urls=complete_audio_urls,
             video_urls=complete_video_urls
         )
+        if memory_manager and active_turn_id:
+            memory_manager.ingest_assistant_response(
+                complete_response_obj,
+                turn_id=active_turn_id,
+                source_event="LLMCompleteResponseReceivedEvent",
+            )
+            if token_usage and llm_config and llm_model:
+                budget = resolve_token_budget(llm_model, llm_config, memory_manager.compaction_policy)
+                if budget:
+                    apply_compaction_policy(memory_manager.compaction_policy, budget)
+                    if memory_manager.compactor and memory_manager.compaction_policy.should_compact(
+                        token_usage.prompt_tokens,
+                        budget.input_budget,
+                    ):
+                        memory_manager.request_compaction()
         llm_complete_event = LLMCompleteResponseReceivedEvent(
             complete_response=complete_response_obj
         )
         await context.input_event_queues.enqueue_internal_system_event(llm_complete_event)
         logger.info(f"Agent '{agent_id}' enqueued LLMCompleteResponseReceivedEvent from LLMUserMessageReadyEventHandler.")
-

autobyteus/agent/handlers/tool_execution_approval_event_handler.py

@@ -62,16 +62,6 @@ class ToolExecutionApprovalEventHandler(AgentEventHandler):
             )
 
             denial_reason_str = event.reason or "No specific reason provided."
-            denial_content_for_history = f"Tool execution denied by user/system. Reason: {denial_reason_str}"
-            
-            context.state.add_message_to_history({
-                "role": "tool",
-                "tool_call_id": event.tool_invocation_id, 
-                "name": retrieved_invocation.name,
-                "content": denial_content_for_history,
-            })
-            logger.debug(f"Agent '{context.agent_id}': Added 'tool' role denial message to history for '{retrieved_invocation.name}' (ID: {event.tool_invocation_id}).")
-            
             prompt_content_for_llm = (
                 f"The request to use the tool '{retrieved_invocation.name}' "
                 f"(with arguments: {json.dumps(retrieved_invocation.arguments or {})}) was denied. "

autobyteus/agent/handlers/tool_invocation_request_event_handler.py

@@ -1,12 +1,12 @@
 # file: autobyteus/autobyteus/agent/handlers/tool_invocation_request_event_handler.py
 import logging
-import json 
 import traceback 
 from typing import TYPE_CHECKING, Optional 
 
 from autobyteus.agent.handlers.base_event_handler import AgentEventHandler
 from autobyteus.agent.events import PendingToolInvocationEvent, ToolResultEvent 
 from autobyteus.agent.tool_invocation import ToolInvocation
+from autobyteus.utils.llm_output_formatter import format_to_clean_string
 
 if TYPE_CHECKING:
     from autobyteus.agent.context import AgentContext 
@@ -46,10 +46,35 @@ class ToolInvocationRequestEventHandler(AgentEventHandler):
             except Exception as e_notify:
                 logger.error(f"Agent '{agent_id}': Error notifying tool auto-execution: {e_notify}", exc_info=True)
         
+        # Run tool invocation preprocessors (if any) before execution
+        processors = context.config.tool_invocation_preprocessors
+        if processors:
+            # Filter valid processors first to avoid sorting crashes (checking for get_order attribute)
+            valid_processors = [p for p in processors if hasattr(p, 'get_order')]
+            sorted_processors = sorted(valid_processors, key=lambda p: p.get_order())
+            for processor in sorted_processors:
+                try:
+                    tool_invocation = await processor.process(tool_invocation, context)
+                    tool_name = tool_invocation.name
+                    arguments = tool_invocation.arguments
+                    invocation_id = tool_invocation.id
+                except Exception as e:
+                    error_message = f"Error in tool invocation preprocessor '{processor.get_name()}' for tool '{tool_name}': {e}"
+                    logger.error(f"Agent '{agent_id}': {error_message}", exc_info=True)
+                    result_event = ToolResultEvent(
+                        tool_name=tool_name,
+                        result=None,
+                        error=error_message,
+                        tool_invocation_id=invocation_id,
+                        turn_id=tool_invocation.turn_id,
+                    )
+                    await context.input_event_queues.enqueue_tool_result(result_event)
+                    return
+
         logger.info(f"Agent '{agent_id}' executing tool directly: '{tool_name}' (ID: {invocation_id}) with args: {arguments}")
         
         try:
-            args_str = json.dumps(arguments)
+            args_str = format_to_clean_string(arguments)
         except TypeError:
             args_str = str(arguments) 
 
@@ -71,13 +96,13 @@ class ToolInvocationRequestEventHandler(AgentEventHandler):
         if not tool_instance:
             error_message = f"Tool '{tool_name}' not found or configured for agent '{agent_id}'."
             logger.error(error_message)
-            result_event = ToolResultEvent(tool_name=tool_name, result=None, error=error_message, tool_invocation_id=invocation_id)
-            context.add_message_to_history({ 
-                "role": "tool",
-                "tool_call_id": invocation_id,
-                "name": tool_name,
-                "content": f"Error: Tool '{tool_name}' execution failed. Reason: {error_message}",
-            })
+            result_event = ToolResultEvent(
+                tool_name=tool_name,
+                result=None,
+                error=error_message,
+                tool_invocation_id=invocation_id,
+                turn_id=tool_invocation.turn_id,
+            )
             log_msg_error = f"[TOOL_ERROR_DIRECT] {error_message}"
             if notifier:
                 try:
@@ -97,20 +122,19 @@ class ToolInvocationRequestEventHandler(AgentEventHandler):
                 execution_result = await tool_instance.execute(context=context, **arguments) 
                 
                 try:
-                    result_json_for_log = json.dumps(execution_result)
+                    result_json_for_log = format_to_clean_string(execution_result)
                 except (TypeError, ValueError): 
-                    result_json_for_log = json.dumps(str(execution_result))
+                    result_json_for_log = format_to_clean_string(str(execution_result))
 
                 logger.info(f"Tool '{tool_name}' (ID: {invocation_id}) executed by agent '{agent_id}'.")
-                result_event = ToolResultEvent(tool_name=tool_name, result=execution_result, error=None, tool_invocation_id=invocation_id)
-                
-                history_content = str(execution_result) 
-                context.add_message_to_history({ 
-                    "role": "tool",
-                    "tool_call_id": invocation_id,
-                    "name": tool_name,
-                    "content": history_content,
-                })
+                result_event = ToolResultEvent(
+                    tool_name=tool_name,
+                    result=execution_result,
+                    error=None,
+                    tool_invocation_id=invocation_id,
+                    tool_args=arguments,
+                    turn_id=tool_invocation.turn_id,
+                )
                 log_msg_result = f"[TOOL_RESULT_DIRECT] {result_json_for_log}"
                 if notifier:
                     try:
@@ -124,13 +148,13 @@ class ToolInvocationRequestEventHandler(AgentEventHandler):
                 error_message = f"Error executing tool '{tool_name}' (ID: {invocation_id}): {str(e)}"
                 error_details = traceback.format_exc()
                 logger.error(f"Agent '{agent_id}' {error_message}", exc_info=True)
-                result_event = ToolResultEvent(tool_name=tool_name, result=None, error=error_message, tool_invocation_id=invocation_id)
-                context.add_message_to_history({ 
-                    "role": "tool",
-                    "tool_call_id": invocation_id,
-                    "name": tool_name,
-                    "content": f"Error: Tool '{tool_name}' execution failed. Reason: {error_message}",
-                })
+                result_event = ToolResultEvent(
+                    tool_name=tool_name,
+                    result=None,
+                    error=error_message,
+                    tool_invocation_id=invocation_id,
+                    turn_id=tool_invocation.turn_id,
+                )
                 log_msg_exception = f"[TOOL_EXCEPTION_DIRECT] {error_message}\nDetails:\n{error_details}"
                 if notifier:
                     try:
@@ -161,8 +185,8 @@ class ToolInvocationRequestEventHandler(AgentEventHandler):
         agent_id = context.agent_id 
         
         notifier: Optional['AgentExternalEventNotifier'] = None
-        if context.phase_manager:
-            notifier = context.phase_manager.notifier
+        if context.status_manager:
+            notifier = context.status_manager.notifier
         
         if not notifier:
             logger.error(f"Agent '{agent_id}': Notifier not available in ToolInvocationRequestEventHandler. Output events for tool approval/logging will be lost.")
@@ -175,25 +199,6 @@ class ToolInvocationRequestEventHandler(AgentEventHandler):
             
             context.store_pending_tool_invocation(tool_invocation) 
 
-            try:
-                arguments_json_str = json.dumps(tool_invocation.arguments or {})
-            except TypeError: 
-                logger.warning(f"Could not serialize args for history tool_call for '{tool_invocation.name}'. Using empty dict string.")
-                arguments_json_str = "{}"
-
-            context.add_message_to_history({ 
-                "role": "assistant",
-                "content": None, 
-                "tool_calls": [{
-                    "id": tool_invocation.id,
-                    "type": "function", 
-                    "function": {
-                        "name": tool_invocation.name,
-                        "arguments": arguments_json_str 
-                    }
-                }]
-            })
-            
             approval_data = {
                 "invocation_id": tool_invocation.id,
                 "tool_name": tool_invocation.name,

autobyteus/agent/handlers/tool_result_event_handler.py

@@ -1,6 +1,6 @@
 # file: autobyteus/autobyteus/agent/handlers/tool_result_event_handler.py
 import logging
-import json 
+
 from typing import TYPE_CHECKING, Optional, List
 
 from autobyteus.agent.handlers.base_event_handler import AgentEventHandler 
@@ -9,6 +9,7 @@ from autobyteus.agent.tool_execution_result_processor import BaseToolExecutionRe
 from autobyteus.agent.message.context_file import ContextFile
 from autobyteus.agent.message import AgentInputUserMessage
 from autobyteus.agent.sender_type import SenderType
+from autobyteus.utils.llm_output_formatter import format_to_clean_string
 
 if TYPE_CHECKING:
     from autobyteus.agent.context import AgentContext 
@@ -81,10 +82,7 @@ class ToolResultEventHandler(AgentEventHandler):
                 aggregated_content_parts.append(content_part)
             # Handle standard text/JSON results
             else:
-                try:
-                    result_str = json.dumps(p_event.result, indent=2) if not isinstance(p_event.result, str) else p_event.result
-                except TypeError: # pragma: no cover
-                    result_str = str(p_event.result)
+                result_str = format_to_clean_string(p_event.result)
                 content_part = (
                     f"Tool: {p_event.tool_name} (ID: {tool_invocation_id})\n"
                     f"Status: Success\n"
@@ -120,7 +118,7 @@ class ToolResultEventHandler(AgentEventHandler):
             return
 
         agent_id = context.agent_id
-        notifier: Optional['AgentExternalEventNotifier'] = context.phase_manager.notifier if context.phase_manager else None
+        notifier: Optional['AgentExternalEventNotifier'] = context.status_manager.notifier if context.status_manager else None
 
         # --- Step 1: Immediately process the incoming event ---
         processed_event = event
@@ -144,7 +142,7 @@ class ToolResultEventHandler(AgentEventHandler):
             if processed_event.error:
                 log_message = f"[TOOL_RESULT_ERROR_PROCESSED] Agent_ID: {agent_id}, Tool: {processed_event.tool_name}, Invocation_ID: {tool_invocation_id}, Error: {processed_event.error}"
             else:
-                log_message = f"[TOOL_RESULT_SUCCESS_PROCESSED] Agent_ID: {agent_id}, Tool: {processed_event.tool_name}, Invocation_ID: {tool_invocation_id}, Result: {str(processed_event.result)}"
+                log_message = f"[TOOL_RESULT_SUCCESS_PROCESSED] Agent_ID: {agent_id}, Tool: {processed_event.tool_name}, Invocation_ID: {tool_invocation_id}, Result: {format_to_clean_string(processed_event.result)}"
             
             try:
                 log_data = {
@@ -195,7 +193,8 @@ class ToolResultEventHandler(AgentEventHandler):
                     tool_name=original_invocation.name,
                     result=None,
                     error=f"Critical Error: Result for this tool call was lost.",
-                    tool_invocation_id=original_invocation.id
+                    tool_invocation_id=original_invocation.id,
+                    turn_id=original_invocation.turn_id,
                 ))
 
         await self._dispatch_results_to_input_pipeline(sorted_results, context)

autobyteus/agent/handlers/user_input_message_event_handler.py

@@ -39,8 +39,8 @@ class UserInputMessageEventHandler(AgentEventHandler):
 
         # --- UPDATED LOGIC: Check sender_type for system-generated tasks and notify TUI ---
         if original_agent_input_user_msg.sender_type == SenderType.SYSTEM:
-            if context.phase_manager:
-                notifier: 'AgentExternalEventNotifier' = context.phase_manager.notifier
+            if context.status_manager:
+                notifier: 'AgentExternalEventNotifier' = context.status_manager.notifier
                 notification_data = {
                     "sender_id": original_agent_input_user_msg.metadata.get("sender_id", "system"),
                     "content": original_agent_input_user_msg.content,
@@ -59,8 +59,15 @@ class UserInputMessageEventHandler(AgentEventHandler):
 
         processor_instances = context.config.input_processors
         if processor_instances:
+            valid_processors = []
+            for p in processor_instances:
+                if isinstance(p, BaseAgentUserInputMessageProcessor):
+                    valid_processors.append(p)
+                else:
+                    logger.error(f"Agent '{context.agent_id}': Invalid input processor type in config: {type(p)}. Skipping.")
+
             # Sort processors by their order attribute
-            sorted_processors = sorted(processor_instances, key=lambda p: p.get_order())
+            sorted_processors = sorted(valid_processors, key=lambda p: p.get_order())
             processor_names = [p.get_name() for p in sorted_processors]
             logger.debug(f"Agent '{context.agent_id}': Applying input processors in order: {processor_names}")
             

autobyteus/agent/input_processor/memory_ingest_input_processor.py

@@ -0,0 +1,40 @@
+import logging
+from typing import TYPE_CHECKING
+
+from autobyteus.agent.input_processor.base_user_input_processor import BaseAgentUserInputMessageProcessor
+from autobyteus.agent.message.multimodal_message_builder import build_llm_user_message
+
+if TYPE_CHECKING:
+    from autobyteus.agent.message.agent_input_user_message import AgentInputUserMessage
+    from autobyteus.agent.context import AgentContext
+    from autobyteus.agent.events import UserMessageReceivedEvent
+
+logger = logging.getLogger(__name__)
+
+
+class MemoryIngestInputProcessor(BaseAgentUserInputMessageProcessor):
+    @classmethod
+    def get_order(cls) -> int:
+        return 900
+
+    async def process(
+        self,
+        message: "AgentInputUserMessage",
+        context: "AgentContext",
+        triggering_event: "UserMessageReceivedEvent",
+    ) -> "AgentInputUserMessage":
+        memory_manager = getattr(context.state, "memory_manager", None)
+        if not memory_manager:
+            return message
+
+        turn_id = memory_manager.start_turn()
+        context.state.active_turn_id = turn_id
+
+        llm_user_message = build_llm_user_message(message)
+        memory_manager.ingest_user_message(
+            llm_user_message,
+            turn_id=turn_id,
+            source_event="LLMUserMessageReadyEvent",
+        )
+        logger.debug("MemoryIngestInputProcessor stored processed user input with turn_id %s", turn_id)
+        return message

autobyteus/agent/lifecycle/__init__.py

@@ -0,0 +1,12 @@
+# file: autobyteus/agent/lifecycle/__init__.py
+"""
+Lifecycle module provides simplified extension points for agent lifecycle events.
+Replaces the more complex Status Hooks system with a simple processor pattern.
+"""
+from autobyteus.agent.lifecycle.events import LifecycleEvent
+from autobyteus.agent.lifecycle.base_processor import BaseLifecycleEventProcessor
+
+__all__ = [
+    "LifecycleEvent",
+    "BaseLifecycleEventProcessor",
+]