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

autobyteus/agent/factory/agent_factory.py

@@ -1,6 +1,8 @@
 # file: autobyteus/autobyteus/agent/factory/agent_factory.py
 import logging
 import random
+import os
+from pathlib import Path
 from typing import Optional, TYPE_CHECKING, Dict, List
 
 # LLMFactory is no longer needed here.
@@ -13,6 +15,11 @@ from autobyteus.agent.workspace.base_workspace import BaseAgentWorkspace
 from autobyteus.agent.handlers import *
 from autobyteus.utils.singleton import SingletonMeta
 from autobyteus.tools.base_tool import BaseTool
+from autobyteus.memory import FileMemoryStore, MemoryManager
+from autobyteus.agent.input_processor.memory_ingest_input_processor import MemoryIngestInputProcessor
+from autobyteus.agent.tool_execution_result_processor.memory_ingest_tool_result_processor import (
+    MemoryIngestToolResultProcessor,
+)
 
 if TYPE_CHECKING:
     from autobyteus.agent.runtime.agent_runtime import AgentRuntime
@@ -41,9 +48,16 @@ class AgentFactory(metaclass=SingletonMeta):
         registry.register(ToolExecutionApprovalEvent, ToolExecutionApprovalEventHandler())
         registry.register(LLMUserMessageReadyEvent, LLMUserMessageReadyEventHandler())
         registry.register(ApprovedToolInvocationEvent, ApprovedToolInvocationEventHandler())
+        bootstrap_handler = BootstrapEventHandler()
+        registry.register(BootstrapStartedEvent, bootstrap_handler)
+        registry.register(BootstrapStepRequestedEvent, bootstrap_handler)
+        registry.register(BootstrapStepCompletedEvent, bootstrap_handler)
+        registry.register(BootstrapCompletedEvent, bootstrap_handler)
         lifecycle_logger_instance = LifecycleEventLogger()
         registry.register(AgentReadyEvent, lifecycle_logger_instance)
         registry.register(AgentStoppedEvent, lifecycle_logger_instance)
+        registry.register(AgentIdleEvent, lifecycle_logger_instance)
+        registry.register(ShutdownRequestedEvent, lifecycle_logger_instance)
         registry.register(AgentErrorEvent, lifecycle_logger_instance)
         return registry
 
@@ -69,18 +83,56 @@ class AgentFactory(metaclass=SingletonMeta):
         
         return tool_instances_dict
 
+    def _prepare_skills(self, agent_id: str, config: AgentConfig):
+        """
+        Registers skills from paths and ensures all skill names are valid.
+        """
+        from autobyteus.skills.registry import SkillRegistry
+        import os
+
+        registry = SkillRegistry()
+        updated_skills = []
+        for skill_item in config.skills:
+            # Check if it's a path (absolute or relative to current working directory)
+            if os.path.isabs(skill_item) or os.path.exists(skill_item):
+                try:
+                    skill = registry.register_skill_from_path(skill_item)
+                    updated_skills.append(skill.name)
+                except Exception as e:
+                    logger.error(f"Agent '{agent_id}': Failed to register skill from path '{skill_item}': {e}")
+            else:
+                updated_skills.append(skill_item)
+        
+        config.skills = updated_skills
+
     def _create_runtime(self, 
                         agent_id: str, 
                         config: AgentConfig
                         ) -> 'AgentRuntime': 
         from autobyteus.agent.runtime.agent_runtime import AgentRuntime 
 
+        # Prepare skills (resolve paths to names and register them)
+        self._prepare_skills(agent_id, config)
+
         # The workspace and initial custom data are now passed directly from the config to the state.
         runtime_state = AgentRuntimeState(
             agent_id=agent_id,
             workspace=config.workspace,
             custom_data=config.initial_custom_data
         )
+
+        # Memory manager (file-backed) initialization
+        memory_dir = os.getenv("AUTOBYTEUS_MEMORY_DIR")
+        if memory_dir is None:
+            memory_dir = str(Path.cwd() / "memory")
+        memory_store = FileMemoryStore(base_dir=memory_dir, agent_id=agent_id)
+        runtime_state.memory_manager = MemoryManager(store=memory_store)
+
+        # Ensure memory ingest processors are present
+        if not any(isinstance(p, MemoryIngestInputProcessor) for p in config.input_processors):
+            config.input_processors.append(MemoryIngestInputProcessor())
+        if not any(isinstance(p, MemoryIngestToolResultProcessor) for p in config.tool_execution_result_processors):
+            config.tool_execution_result_processors.append(MemoryIngestToolResultProcessor())
         
         # --- Set pre-initialized instances on the state ---
         runtime_state.llm_instance = config.llm_instance

autobyteus/agent/handlers/__init__.py

@@ -14,6 +14,7 @@ from .tool_invocation_request_event_handler import ToolInvocationRequestEventHan
 from .tool_result_event_handler import ToolResultEventHandler
 from .approved_tool_invocation_event_handler import ApprovedToolInvocationEventHandler
 from .tool_execution_approval_event_handler import ToolExecutionApprovalEventHandler
+from .bootstrap_event_handler import BootstrapEventHandler
 
 # General Purpose and Lifecycle Handlers
 from .generic_event_handler import GenericEventHandler
@@ -31,6 +32,7 @@ __all__ = [
     "ToolResultEventHandler",
     "ApprovedToolInvocationEventHandler",
     "ToolExecutionApprovalEventHandler",
+    "BootstrapEventHandler",
     "GenericEventHandler",
     "LifecycleEventLogger", 
 ]

autobyteus/agent/handlers/approved_tool_invocation_event_handler.py

@@ -1,12 +1,13 @@
 # file: autobyteus/autobyteus/agent/handlers/approved_tool_invocation_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 ApprovedToolInvocationEvent, 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 
@@ -38,18 +39,38 @@ class ApprovedToolInvocationEventHandler(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: # pragma: no cover
             logger.error(f"Agent '{agent_id}': Notifier not available in ApprovedToolInvocationEventHandler. Tool interaction logs will not be emitted.")
 
         logger.info(f"Agent '{agent_id}' handling ApprovedToolInvocationEvent for tool: '{tool_name}' (ID: {invocation_id}) with args: {arguments}")
 
-        try:
-            args_str = json.dumps(arguments)
-        except TypeError: # pragma: no cover
-            args_str = str(arguments) 
+        # Run tool invocation preprocessors before execution
+        processors = context.config.tool_invocation_preprocessors
+        if processors:
+            sorted_processors = sorted(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
+
+        args_str = format_to_clean_string(arguments) 
         log_msg_call = f"[APPROVED_TOOL_CALL] Agent_ID: {agent_id}, Tool: {tool_name}, Invocation_ID: {invocation_id}, Arguments: {args_str}"
         
         if notifier:
@@ -69,13 +90,13 @@ class ApprovedToolInvocationEventHandler(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: Approved 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"[APPROVED_TOOL_ERROR] {error_message}"
             if notifier:
                 try:
@@ -94,21 +115,17 @@ class ApprovedToolInvocationEventHandler(AgentEventHandler):
                 logger.debug(f"Executing approved tool '{tool_name}' for agent '{agent_id}'. Invocation ID: {invocation_id}")
                 execution_result = await tool_instance.execute(context=context, **arguments)
                 
-                try:
-                    result_json_for_log = json.dumps(execution_result)
-                except (TypeError, ValueError): 
-                    result_json_for_log = json.dumps(str(execution_result))
+                result_json_for_log = format_to_clean_string(execution_result)
 
                 logger.info(f"Approved tool '{tool_name}' (ID: {invocation_id}) executed successfully 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"[APPROVED_TOOL_RESULT] {result_json_for_log}"
                 if notifier:
                     try:
@@ -122,13 +139,13 @@ class ApprovedToolInvocationEventHandler(AgentEventHandler):
                 error_message = f"Error executing approved 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: Approved 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"[APPROVED_TOOL_EXCEPTION] {error_message}\nDetails:\n{error_details}"
                 if notifier:
                     try:

autobyteus/agent/handlers/bootstrap_event_handler.py

@@ -0,0 +1,155 @@
+# file: autobyteus/autobyteus/agent/handlers/bootstrap_event_handler.py
+import logging
+from typing import List, Optional, TYPE_CHECKING
+
+from autobyteus.agent.bootstrap_steps.agent_bootstrapper import AgentBootstrapper
+from autobyteus.agent.bootstrap_steps.base_bootstrap_step import BaseBootstrapStep
+from autobyteus.agent.events import (
+    AgentErrorEvent,
+    AgentReadyEvent,
+    BootstrapStartedEvent,
+    BootstrapStepRequestedEvent,
+    BootstrapStepCompletedEvent,
+    BootstrapCompletedEvent,
+)
+from autobyteus.agent.handlers.base_event_handler import AgentEventHandler
+
+if TYPE_CHECKING:
+    from autobyteus.agent.context import AgentContext
+
+logger = logging.getLogger(__name__)
+
+_BOOTSTRAP_STEPS_KEY = "_bootstrap_steps"
+
+
+class BootstrapEventHandler(AgentEventHandler):
+    """
+    Orchestrates the agent bootstrap sequence using internal lifecycle events.
+    """
+
+    def __init__(self, steps: Optional[List[BaseBootstrapStep]] = None) -> None:
+        self._bootstrapper = AgentBootstrapper(steps=steps)
+
+    async def handle(self, event: object, context: 'AgentContext') -> None:
+        if isinstance(event, BootstrapStartedEvent):
+            await self._handle_bootstrap_started(context)
+            return
+
+        if isinstance(event, BootstrapStepRequestedEvent):
+            await self._handle_bootstrap_step_requested(event, context)
+            return
+
+        if isinstance(event, BootstrapStepCompletedEvent):
+            await self._handle_bootstrap_step_completed(event, context)
+            return
+
+        if isinstance(event, BootstrapCompletedEvent):
+            await self._handle_bootstrap_completed(event, context)
+            return
+
+        logger.warning(f"BootstrapEventHandler received unexpected event type: {type(event).__name__}")
+
+    async def _handle_bootstrap_started(self, context: 'AgentContext') -> None:
+        steps = list(self._bootstrapper.bootstrap_steps)
+        context.state.custom_data[_BOOTSTRAP_STEPS_KEY] = steps
+
+        if not steps:
+            logger.info(f"Agent '{context.agent_id}': No bootstrap steps configured. Marking bootstrap complete.")
+            await context.input_event_queues.enqueue_internal_system_event(
+                BootstrapCompletedEvent(success=True)
+            )
+            return
+
+        logger.info(f"Agent '{context.agent_id}': Bootstrap started with {len(steps)} steps.")
+        await context.input_event_queues.enqueue_internal_system_event(
+            BootstrapStepRequestedEvent(step_index=0)
+        )
+
+    async def _handle_bootstrap_step_requested(self, event: BootstrapStepRequestedEvent, context: 'AgentContext') -> None:
+        steps: Optional[List[BaseBootstrapStep]] = context.state.custom_data.get(_BOOTSTRAP_STEPS_KEY)
+        if not steps:
+            error_message = "Bootstrap steps list missing from context during step request."
+            logger.error(f"Agent '{context.agent_id}': {error_message}")
+            await self._notify_bootstrap_error(context, error_message)
+            await context.input_event_queues.enqueue_internal_system_event(
+                BootstrapCompletedEvent(success=False, error_message=error_message)
+            )
+            return
+
+        step_index = event.step_index
+        if step_index < 0 or step_index >= len(steps):
+            error_message = f"Invalid bootstrap step index {step_index}."
+            logger.error(f"Agent '{context.agent_id}': {error_message}")
+            await self._notify_bootstrap_error(context, error_message)
+            await context.input_event_queues.enqueue_internal_system_event(
+                BootstrapCompletedEvent(success=False, error_message=error_message)
+            )
+            return
+
+        step = steps[step_index]
+        step_name = step.__class__.__name__
+        logger.debug(f"Agent '{context.agent_id}': Executing bootstrap step {step_index + 1}/{len(steps)}: {step_name}")
+
+        try:
+            success = await step.execute(context)
+        except Exception as e:  # pragma: no cover
+            error_message = f"Exception during bootstrap step '{step_name}': {e}"
+            logger.error(f"Agent '{context.agent_id}': {error_message}", exc_info=True)
+            success = False
+        if not success:
+            error_message = f"Bootstrap step '{step_name}' failed."
+            await self._notify_bootstrap_error(context, error_message)
+
+        await context.input_event_queues.enqueue_internal_system_event(
+            BootstrapStepCompletedEvent(
+                step_index=step_index,
+                step_name=step_name,
+                success=success,
+                error_message=None if success else f"Step '{step_name}' failed",
+            )
+        )
+
+    async def _handle_bootstrap_step_completed(self, event: BootstrapStepCompletedEvent, context: 'AgentContext') -> None:
+        if not event.success:
+            await context.input_event_queues.enqueue_internal_system_event(
+                BootstrapCompletedEvent(success=False, error_message=event.error_message)
+            )
+            return
+
+        steps: Optional[List[BaseBootstrapStep]] = context.state.custom_data.get(_BOOTSTRAP_STEPS_KEY)
+        if not steps:
+            error_message = "Bootstrap steps list missing during step completion."
+            logger.error(f"Agent '{context.agent_id}': {error_message}")
+            await self._notify_bootstrap_error(context, error_message)
+            await context.input_event_queues.enqueue_internal_system_event(
+                BootstrapCompletedEvent(success=False, error_message=error_message)
+            )
+            return
+
+        next_index = event.step_index + 1
+        if next_index < len(steps):
+            await context.input_event_queues.enqueue_internal_system_event(
+                BootstrapStepRequestedEvent(step_index=next_index)
+            )
+            return
+
+        await context.input_event_queues.enqueue_internal_system_event(
+            BootstrapCompletedEvent(success=True)
+        )
+
+    async def _handle_bootstrap_completed(self, event: BootstrapCompletedEvent, context: 'AgentContext') -> None:
+        if not event.success:
+            logger.error(
+                f"Agent '{context.agent_id}': Bootstrap completed with failure. "
+                f"Error: {event.error_message}"
+            )
+            await self._notify_bootstrap_error(context, event.error_message or "Bootstrap failed.")
+            return
+
+        logger.info(f"Agent '{context.agent_id}': Bootstrap completed successfully. Emitting AgentReadyEvent.")
+        await context.input_event_queues.enqueue_internal_system_event(AgentReadyEvent())
+
+    async def _notify_bootstrap_error(self, context: 'AgentContext', error_message: str) -> None:
+        await context.input_event_queues.enqueue_internal_system_event(
+            AgentErrorEvent(error_message=error_message, exception_details=error_message)
+        )

autobyteus/agent/handlers/inter_agent_message_event_handler.py

@@ -48,6 +48,16 @@ class InterAgentMessageReceivedEventHandler(AgentEventHandler):
             f"'{inter_agent_msg.sender_agent_id}', type '{inter_agent_msg.message_type.value}'. "
             f"Content: '{inter_agent_msg.content}'"
         )
+
+        # Surface this inter-agent message to external subscribers (UI, etc.)
+        if context.status_manager and context.status_manager.notifier:
+            notifier: 'AgentExternalEventNotifier' = context.status_manager.notifier
+            notifier.notify_agent_data_inter_agent_message_received({
+                "sender_agent_id": inter_agent_msg.sender_agent_id,
+                "recipient_role_name": inter_agent_msg.recipient_role_name,
+                "content": inter_agent_msg.content,
+                "message_type": inter_agent_msg.message_type.value,
+            })
         
         content_for_llm = (
             f"You have received a message from another agent.\n"

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: