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

autobyteus/agent/handlers/lifecycle_event_logger.py

@@ -8,9 +8,11 @@ from autobyteus.agent.events import (
     AgentReadyEvent, # MODIFIED: Renamed from AgentStartedEvent
     AgentStoppedEvent,
     AgentErrorEvent,
+    AgentIdleEvent,
+    ShutdownRequestedEvent,
     LifecycleEvent 
 )
-from autobyteus.agent.phases import AgentOperationalPhase # Import new phase enum
+from autobyteus.agent.status.status_enum import AgentStatus # Import new status enum
 
 if TYPE_CHECKING:
     from autobyteus.agent.context import AgentContext 
@@ -20,8 +22,8 @@ logger = logging.getLogger(__name__)
 class LifecycleEventLogger(AgentEventHandler): 
     """
     Logs various lifecycle events for an agent.
-    This handler does not modify agent state directly; phase changes are managed
-    by AgentPhaseManager.
+    This handler does not modify agent state directly; status changes are projected
+    from events.
     """
 
     async def handle(self,
@@ -32,33 +34,39 @@ class LifecycleEventLogger(AgentEventHandler):
 
         Args:
             event: The lifecycle event object (AgentReadyEvent, AgentStoppedEvent, etc.).
-            context: The composite AgentContext (used for agent_id and current phase).
+            context: The composite AgentContext (used for agent_id and current status).
         """
         
         agent_id = context.agent_id 
-        # MODIFIED: Use current_phase instead of status
-        current_phase_val = context.current_phase.value if context.current_phase else "None (Phase not set)"
+        # MODIFIED: Use current_status instead of status
+        current_status_val = context.current_status.value if context.current_status else "None (Status not set)"
 
         if isinstance(event, AgentReadyEvent): # MODIFIED: Check for AgentReadyEvent
-            logger.info(f"Agent '{agent_id}' Logged AgentReadyEvent. Current agent phase: {current_phase_val}") # MODIFIED log message
+            logger.info(f"Agent '{agent_id}' Logged AgentReadyEvent. Current agent status: {current_status_val}") # MODIFIED log message
 
         elif isinstance(event, AgentStoppedEvent):
-            logger.info(f"Agent '{agent_id}' Logged AgentStoppedEvent. Current agent phase: {current_phase_val}")
+            logger.info(f"Agent '{agent_id}' Logged AgentStoppedEvent. Current agent status: {current_status_val}")
+
+        elif isinstance(event, AgentIdleEvent):
+            logger.info(f"Agent '{agent_id}' Logged AgentIdleEvent. Current agent status: {current_status_val}")
+
+        elif isinstance(event, ShutdownRequestedEvent):
+            logger.info(f"Agent '{agent_id}' Logged ShutdownRequestedEvent. Current agent status: {current_status_val}")
 
         elif isinstance(event, AgentErrorEvent):
             logger.error(
                 f"Agent '{agent_id}' Logged AgentErrorEvent: {event.error_message}. "
-                f"Details: {event.exception_details}. Current agent phase: {current_phase_val}"
+                f"Details: {event.exception_details}. Current agent status: {current_status_val}"
             )
 
         else: # pragma: no cover
             if isinstance(event, LifecycleEvent): 
                  logger.warning(
                      f"LifecycleEventLogger for agent '{agent_id}' received an unhandled "
-                     f"specific LifecycleEvent type: {type(event)}. Event: {event}. Current phase: {current_phase_val}"
+                     f"specific LifecycleEvent type: {type(event)}. Event: {event}. Current status: {current_status_val}"
                  )
             else: 
                  logger.warning(
                      f"LifecycleEventLogger for agent '{agent_id}' received an "
-                     f"unexpected event type: {type(event)}. Event: {event}. Current phase: {current_phase_val}"
+                     f"unexpected event type: {type(event)}. Event: {event}. Current status: {current_status_val}"
                  )

autobyteus/agent/handlers/llm_complete_response_received_event_handler.py

@@ -6,7 +6,6 @@ from autobyteus.agent.handlers.base_event_handler import AgentEventHandler
 from autobyteus.agent.events import LLMCompleteResponseReceivedEvent 
 from autobyteus.llm.utils.response_types import CompleteResponse
 from autobyteus.agent.llm_response_processor import BaseLLMResponseProcessor
-from autobyteus.tools.usage.parsers.exceptions import ToolUsageParseException
 
 
 if TYPE_CHECKING:
@@ -49,8 +48,8 @@ class LLMCompleteResponseReceivedEventHandler(AgentEventHandler):
         any_processor_took_action = False
         
         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 LLMCompleteResponseReceivedEventHandler. Cannot emit complete response event.")
@@ -63,8 +62,15 @@ class LLMCompleteResponseReceivedEventHandler(AgentEventHandler):
                     f"Proceeding to treat LLM response as output for this leg."
                 )
             else:
+                valid_processors = []
+                for p in processor_instances_to_try:
+                    if isinstance(p, BaseLLMResponseProcessor):
+                        valid_processors.append(p)
+                    else:
+                        logger.error(f"Agent '{agent_id}': Invalid LLM response processor type in config: {type(p)}. Skipping.")
+
                 # Sort processors by their order attribute
-                sorted_processors = sorted(processor_instances_to_try, 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 '{agent_id}': Attempting LLM response processing in order: {processor_names}")
 
@@ -94,17 +100,6 @@ class LLMCompleteResponseReceivedEventHandler(AgentEventHandler):
                         else:
                             logger.debug(f"Agent '{agent_id}': LLMResponseProcessor '{processor_name_for_log}' did not handle the response.")
 
-                    except ToolUsageParseException as e_parse:
-                        # This is the key change: Catch the specific parsing exception
-                        logger.warning(f"Agent '{agent_id}': LLMResponseProcessor '{processor_name_for_log}' failed to parse tool usage: {e_parse}")
-                        if notifier:
-                            notifier.notify_agent_error_output_generation( 
-                                error_source=f"LLMResponseProcessor.{processor_name_for_log}",
-                                error_message="The model's response contained a malformed tool call that could not be understood.",
-                                error_details=str(e_parse)
-                            )
-                        # A parsing failure should not prevent other processors from running.
-
                     except Exception as e: # pragma: no cover
                         logger.error(f"Agent '{agent_id}': Error while using LLMResponseProcessor '{processor_name_for_log}': {e}. This processor is skipped.", exc_info=True)
                         if notifier:

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,