autobyteus 1.1.0__py3-none-any.whl → 1.1.1__py3-none-any.whl

autobyteus/agent/handlers/approved_tool_invocation_event_handler.py

@@ -54,7 +54,12 @@ class ApprovedToolInvocationEventHandler(AgentEventHandler):
         
         if notifier:
             try:
-                notifier.notify_agent_data_tool_log(log_msg_call) # USE RENAMED METHOD
+                log_data = {
+                    "log_entry": log_msg_call,
+                    "tool_invocation_id": invocation_id,
+                    "tool_name": tool_name,
+                }
+                notifier.notify_agent_data_tool_log(log_data)
             except Exception as e_notify: 
                  logger.error(f"Agent '{agent_id}': Error notifying approved tool call log: {e_notify}", exc_info=True)
 
@@ -71,11 +76,14 @@ class ApprovedToolInvocationEventHandler(AgentEventHandler):
                 "name": tool_name,
                 "content": f"Error: Approved tool '{tool_name}' execution failed. Reason: {error_message}",
             })
-            log_msg_error = f"[APPROVED_TOOL_ERROR] Agent_ID: {agent_id}, Tool: {tool_name}, Invocation_ID: {invocation_id}, Error: {error_message}"
+            log_msg_error = f"[APPROVED_TOOL_ERROR] {error_message}"
             if notifier:
                 try:
-                    notifier.notify_agent_data_tool_log(log_msg_error) # USE RENAMED METHOD
-                    notifier.notify_agent_error_output_generation( # USE RENAMED METHOD
+                    # Log entry
+                    log_data = { "log_entry": log_msg_error, "tool_invocation_id": invocation_id, "tool_name": tool_name }
+                    notifier.notify_agent_data_tool_log(log_data)
+                    # Generic output error
+                    notifier.notify_agent_error_output_generation(
                         error_source=f"ApprovedToolExecution.ToolNotFound.{tool_name}",
                         error_message=error_message
                     )
@@ -87,11 +95,11 @@ class ApprovedToolInvocationEventHandler(AgentEventHandler):
                 execution_result = await tool_instance.execute(context=context, **arguments)
                 
                 try:
-                    result_str_for_log = json.dumps(execution_result)
-                except TypeError: 
-                    result_str_for_log = str(execution_result)
+                    result_json_for_log = json.dumps(execution_result)
+                except (TypeError, ValueError): 
+                    result_json_for_log = json.dumps(str(execution_result))
 
-                logger.info(f"Approved tool '{tool_name}' (ID: {invocation_id}) executed successfully by agent '{agent_id}'. Result: {result_str_for_log[:200]}...")
+                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) 
@@ -101,15 +109,18 @@ class ApprovedToolInvocationEventHandler(AgentEventHandler):
                     "name": tool_name,
                     "content": history_content,
                 })
-                log_msg_result = f"[APPROVED_TOOL_RESULT] Agent_ID: {agent_id}, Tool: {tool_name}, Invocation_ID: {invocation_id}, Outcome (first 200 chars): {result_str_for_log[:200]}"
+                log_msg_result = f"[APPROVED_TOOL_RESULT] {result_json_for_log}"
                 if notifier:
                     try:
-                        notifier.notify_agent_data_tool_log(log_msg_result) # USE RENAMED METHOD
+                        # Log entry with embedded JSON result
+                        log_data = { "log_entry": log_msg_result, "tool_invocation_id": invocation_id, "tool_name": tool_name }
+                        notifier.notify_agent_data_tool_log(log_data)
                     except Exception as e_notify: 
                         logger.error(f"Agent '{agent_id}': Error notifying approved tool result log: {e_notify}", exc_info=True)
 
             except Exception as e: 
                 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({
@@ -118,14 +129,17 @@ class ApprovedToolInvocationEventHandler(AgentEventHandler):
                     "name": tool_name,
                     "content": f"Error: Approved tool '{tool_name}' execution failed. Reason: {error_message}",
                 })
-                log_msg_exception = f"[APPROVED_TOOL_EXCEPTION] Agent_ID: {agent_id}, Tool: {tool_name}, Invocation_ID: {invocation_id}, Exception: {error_message}"
+                log_msg_exception = f"[APPROVED_TOOL_EXCEPTION] {error_message}\nDetails:\n{error_details}"
                 if notifier:
                     try:
-                        notifier.notify_agent_data_tool_log(log_msg_exception) # USE RENAMED METHOD
-                        notifier.notify_agent_error_output_generation( # USE RENAMED METHOD
+                        # Log entry
+                        log_data = { "log_entry": log_msg_exception, "tool_invocation_id": invocation_id, "tool_name": tool_name }
+                        notifier.notify_agent_data_tool_log(log_data)
+                        # Generic output error
+                        notifier.notify_agent_error_output_generation(
                             error_source=f"ApprovedToolExecution.Exception.{tool_name}",
                             error_message=error_message,
-                            error_details=traceback.format_exc()
+                            error_details=error_details
                         )
                     except Exception as e_notify: 
                         logger.error(f"Agent '{agent_id}': Error notifying approved tool exception log/output error: {e_notify}", exc_info=True)

autobyteus/agent/handlers/lifecycle_event_logger.py

@@ -10,7 +10,7 @@ from autobyteus.agent.events import (
     AgentErrorEvent,
     LifecycleEvent 
 )
-from autobyteus.agent.context.phases import AgentOperationalPhase # Import new phase enum
+from autobyteus.agent.phases import AgentOperationalPhase # Import new phase enum
 
 if TYPE_CHECKING:
     from autobyteus.agent.context import AgentContext 

autobyteus/agent/handlers/llm_complete_response_received_event_handler.py

@@ -42,7 +42,9 @@ class LLMCompleteResponseReceivedEventHandler(AgentEventHandler):
         )
         if complete_response_reasoning:
             logger.debug(f"Agent '{agent_id}' received LLM reasoning for processing:\n---\n{complete_response_reasoning}\n---")
-        logger.debug(f"Agent '{agent_id}' received full LLM content for processing:\n---\n{complete_response_text}\n---")
+        
+        # Changed from .debug to .info as per user request
+        logger.info(f"Agent '{agent_id}' received full LLM content for processing:\n---\n{complete_response_text}\n---")
 
         any_processor_took_action = False
         
@@ -133,4 +135,4 @@ class LLMCompleteResponseReceivedEventHandler(AgentEventHandler):
                     notifier.notify_agent_data_assistant_complete_response(complete_response) 
                     logger.debug(f"Agent '{agent_id}' emitted AGENT_DATA_ASSISTANT_COMPLETE_RESPONSE event.")
                 except Exception as e_notify: # pragma: no cover
-                    logger.error(f"Agent '{agent_id}': Error emitting AGENT_DATA_ASSISTANT_COMPLETE_RESPONSE: {e_notify}", exc_info=True)
+                    logger.error(f"Agent '{agent_id}': Error emitting AGENT_DATA_ASSISTANT_COMPLETE_RESPONSE: {e_notify}", exc_info=True)

autobyteus/agent/handlers/tool_invocation_request_event_handler.py

@@ -34,6 +34,17 @@ class ToolInvocationRequestEventHandler(AgentEventHandler):
         tool_name = tool_invocation.name
         arguments = tool_invocation.arguments
         invocation_id = tool_invocation.id
+
+        if notifier:
+            try:
+                auto_exec_data = {
+                    "invocation_id": invocation_id,
+                    "tool_name": tool_name,
+                    "arguments": arguments,
+                }
+                notifier.notify_agent_tool_invocation_auto_executing(auto_exec_data)
+            except Exception as e_notify:
+                logger.error(f"Agent '{agent_id}': Error notifying tool auto-execution: {e_notify}", exc_info=True)
         
         logger.info(f"Agent '{agent_id}' executing tool directly: '{tool_name}' (ID: {invocation_id}) with args: {arguments}")
         
@@ -45,7 +56,12 @@ class ToolInvocationRequestEventHandler(AgentEventHandler):
         log_msg_call = f"[TOOL_CALL_DIRECT] Agent_ID: {agent_id}, Tool: {tool_name}, Invocation_ID: {invocation_id}, Arguments: {args_str}"
         if notifier:
             try:
-                notifier.notify_agent_data_tool_log(log_msg_call) # USE RENAMED METHOD
+                log_data = {
+                    "log_entry": log_msg_call,
+                    "tool_invocation_id": invocation_id,
+                    "tool_name": tool_name,
+                }
+                notifier.notify_agent_data_tool_log(log_data)
             except Exception as e_notify: 
                  logger.error(f"Agent '{agent_id}': Error notifying tool call log: {e_notify}", exc_info=True)
 
@@ -62,11 +78,14 @@ class ToolInvocationRequestEventHandler(AgentEventHandler):
                 "name": tool_name,
                 "content": f"Error: Tool '{tool_name}' execution failed. Reason: {error_message}",
             })
-            log_msg_error = f"[TOOL_ERROR_DIRECT] Agent_ID: {agent_id}, Tool: {tool_name}, Invocation_ID: {invocation_id}, Error: {error_message}"
+            log_msg_error = f"[TOOL_ERROR_DIRECT] {error_message}"
             if notifier:
                 try:
-                    notifier.notify_agent_data_tool_log(log_msg_error) # USE RENAMED METHOD
-                    notifier.notify_agent_error_output_generation( # USE RENAMED METHOD
+                    # Log entry
+                    log_data = { "log_entry": log_msg_error, "tool_invocation_id": invocation_id, "tool_name": tool_name, }
+                    notifier.notify_agent_data_tool_log(log_data)
+                    # Generic output error
+                    notifier.notify_agent_error_output_generation(
                         error_source=f"ToolExecutionDirect.ToolNotFound.{tool_name}",
                         error_message=error_message
                     )
@@ -78,11 +97,11 @@ class ToolInvocationRequestEventHandler(AgentEventHandler):
                 execution_result = await tool_instance.execute(context=context, **arguments) 
                 
                 try:
-                    result_str_for_log = json.dumps(execution_result)
-                except TypeError: 
-                    result_str_for_log = str(execution_result)
+                    result_json_for_log = json.dumps(execution_result)
+                except (TypeError, ValueError): 
+                    result_json_for_log = json.dumps(str(execution_result))
 
-                logger.info(f"Tool '{tool_name}' (ID: {invocation_id}) executed by agent '{agent_id}'. Result: {result_str_for_log[:200]}...")
+                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) 
@@ -92,15 +111,18 @@ class ToolInvocationRequestEventHandler(AgentEventHandler):
                     "name": tool_name,
                     "content": history_content,
                 })
-                log_msg_result = f"[TOOL_RESULT_DIRECT] Agent_ID: {agent_id}, Tool: {tool_name}, Invocation_ID: {invocation_id}, Outcome (first 200 chars): {result_str_for_log[:200]}"
+                log_msg_result = f"[TOOL_RESULT_DIRECT] {result_json_for_log}"
                 if notifier:
                     try:
-                        notifier.notify_agent_data_tool_log(log_msg_result) # USE RENAMED METHOD
+                        # Log entry with embedded JSON result
+                        log_data = { "log_entry": log_msg_result, "tool_invocation_id": invocation_id, "tool_name": tool_name }
+                        notifier.notify_agent_data_tool_log(log_data)
                     except Exception as e_notify: 
                         logger.error(f"Agent '{agent_id}': Error notifying tool result log: {e_notify}", exc_info=True)
 
             except Exception as e: 
                 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({ 
@@ -109,14 +131,17 @@ class ToolInvocationRequestEventHandler(AgentEventHandler):
                     "name": tool_name,
                     "content": f"Error: Tool '{tool_name}' execution failed. Reason: {error_message}",
                 })
-                log_msg_exception = f"[TOOL_EXCEPTION_DIRECT] Agent_ID: {agent_id}, Tool: {tool_name}, Invocation_ID: {invocation_id}, Exception: {error_message}"
+                log_msg_exception = f"[TOOL_EXCEPTION_DIRECT] {error_message}\nDetails:\n{error_details}"
                 if notifier:
                     try:
-                        notifier.notify_agent_data_tool_log(log_msg_exception) # USE RENAMED METHOD
-                        notifier.notify_agent_error_output_generation( # USE RENAMED METHOD
+                        # Log entry
+                        log_data = { "log_entry": log_msg_exception, "tool_invocation_id": invocation_id, "tool_name": tool_name }
+                        notifier.notify_agent_data_tool_log(log_data)
+                        # Generic output error
+                        notifier.notify_agent_error_output_generation(
                             error_source=f"ToolExecutionDirect.Exception.{tool_name}",
                             error_message=error_message,
-                            error_details=traceback.format_exc()
+                            error_details=error_details
                         )
                     except Exception as e_notify: 
                         logger.error(f"Agent '{agent_id}': Error notifying tool exception log/output error: {e_notify}", exc_info=True)
@@ -176,7 +201,7 @@ class ToolInvocationRequestEventHandler(AgentEventHandler):
             }
             if notifier:
                 try:
-                    notifier.notify_agent_request_tool_invocation_approval(approval_data) # USE RENAMED METHOD
+                    notifier.notify_agent_request_tool_invocation_approval(approval_data)
                     logger.debug(f"Agent '{agent_id}': Emitted AGENT_REQUEST_TOOL_INVOCATION_APPROVAL for '{tool_invocation.name}' (ID: {tool_invocation.id}).")
                 except Exception as e_notify: 
                     logger.error(f"Agent '{agent_id}': Error emitting AGENT_REQUEST_TOOL_INVOCATION_APPROVAL: {e_notify}", exc_info=True)

autobyteus/agent/handlers/tool_result_event_handler.py

@@ -61,7 +61,12 @@ class ToolResultEventHandler(AgentEventHandler):
             log_msg_error_processed = f"[TOOL_RESULT_ERROR_PROCESSED] Agent_ID: {agent_id}, Tool: {event.tool_name}, Invocation_ID: {tool_invocation_id}, Error: {event.error}"
             if notifier:
                 try:
-                    notifier.notify_agent_data_tool_log(log_msg_error_processed) # USE RENAMED METHOD
+                    log_data = {
+                        "log_entry": log_msg_error_processed,
+                        "tool_invocation_id": tool_invocation_id,
+                        "tool_name": event.tool_name,
+                    }
+                    notifier.notify_agent_data_tool_log(log_data)
                 except Exception as e_notify: 
                     logger.error(f"Agent '{agent_id}': Error notifying tool result error log: {e_notify}", exc_info=True)
         else:
@@ -70,11 +75,6 @@ class ToolResultEventHandler(AgentEventHandler):
             except TypeError: # pragma: no cover
                 result_str_for_llm = str(event.result)
 
-            max_len = 2000  
-            if len(result_str_for_llm) > max_len: # pragma: no cover
-                original_len = len(str(event.result)) 
-                result_str_for_llm = result_str_for_llm[:max_len] + f"... (result truncated, original length {original_len})"
-            
             content_for_llm = (
                 f"The tool '{event.tool_name}' (invocation ID: {tool_invocation_id}) has executed.\n"
                 f"Result:\n{result_str_for_llm}\n" 
@@ -83,7 +83,12 @@ class ToolResultEventHandler(AgentEventHandler):
             log_msg_success_processed = f"[TOOL_RESULT_SUCCESS_PROCESSED] Agent_ID: {agent_id}, Tool: {event.tool_name}, Invocation_ID: {tool_invocation_id}, Result (first 200 chars of stringified): {str(event.result)[:200]}"
             if notifier:
                 try:
-                    notifier.notify_agent_data_tool_log(log_msg_success_processed) # USE RENAMED METHOD
+                    log_data = {
+                        "log_entry": log_msg_success_processed,
+                        "tool_invocation_id": tool_invocation_id,
+                        "tool_name": event.tool_name,
+                    }
+                    notifier.notify_agent_data_tool_log(log_data)
                 except Exception as e_notify: 
                     logger.error(f"Agent '{agent_id}': Error notifying tool result success log: {e_notify}", exc_info=True)
         

autobyteus/agent/hooks/__init__.py

@@ -3,7 +3,14 @@
 Components for defining and running lifecycle hooks based on agent phase transitions.
 """
 from .base_phase_hook import BasePhaseHook
+from .hook_definition import PhaseHookDefinition
+from .hook_meta import PhaseHookMeta
+from .hook_registry import PhaseHookRegistry, default_phase_hook_registry
 
 __all__ = [
     "BasePhaseHook",
+    "PhaseHookDefinition",
+    "PhaseHookMeta",
+    "PhaseHookRegistry",
+    "default_phase_hook_registry",
 ]

autobyteus/agent/hooks/base_phase_hook.py

@@ -3,14 +3,15 @@ import logging
 from abc import ABC, abstractmethod
 from typing import TYPE_CHECKING
 
-from autobyteus.agent.context.phases import AgentOperationalPhase
+from autobyteus.agent.phases import AgentOperationalPhase
+from .hook_meta import PhaseHookMeta
 
 if TYPE_CHECKING:
     from autobyteus.agent.context import AgentContext
 
 logger = logging.getLogger(__name__)
 
-class BasePhaseHook(ABC):
+class BasePhaseHook(ABC, metaclass=PhaseHookMeta):
     """
     Abstract base class for creating hooks that execute on specific agent
     phase transitions.
@@ -20,6 +21,14 @@ class BasePhaseHook(ABC):
     method for their custom logic.
     """
 
+    @classmethod
+    def get_name(cls) -> str:
+        """
+        Returns the unique registration name for this hook.
+        Defaults to the class name. Can be overridden by subclasses.
+        """
+        return cls.__name__
+
     @property
     @abstractmethod
     def source_phase(self) -> AgentOperationalPhase:

autobyteus/agent/hooks/hook_definition.py

@@ -0,0 +1,36 @@
+# file: autobyteus/autobyteus/agent/hooks/hook_definition.py
+import logging
+from typing import Type, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from .base_phase_hook import BasePhaseHook
+
+logger = logging.getLogger(__name__)
+
+class PhaseHookDefinition:
+    """
+    Represents the definition of a phase hook.
+    Contains its registered name and the class itself.
+    """
+    def __init__(self, name: str, hook_class: Type['BasePhaseHook']):
+        """
+        Initializes the PhaseHookDefinition.
+
+        Args:
+            name: The unique registered name of the hook.
+            hook_class: The class of the phase hook.
+
+        Raises:
+            ValueError: If name is empty or hook_class is not a type.
+        """
+        if not name or not isinstance(name, str):
+            raise ValueError("Hook name must be a non-empty string.")
+        if not isinstance(hook_class, type):
+            raise ValueError("hook_class must be a class type.")
+        
+        self.name: str = name
+        self.hook_class: Type['BasePhaseHook'] = hook_class
+        logger.debug(f"PhaseHookDefinition created: name='{name}', class='{hook_class.__name__}'.")
+
+    def __repr__(self) -> str:
+        return f"<PhaseHookDefinition name='{self.name}', class='{self.hook_class.__name__}'>"

autobyteus/agent/hooks/hook_meta.py

@@ -0,0 +1,37 @@
+# file: autobyteus/autobyteus/agent/hooks/hook_meta.py
+import logging
+from abc import ABCMeta
+
+from .hook_registry import default_phase_hook_registry
+from .hook_definition import PhaseHookDefinition
+
+logger = logging.getLogger(__name__)
+
+class PhaseHookMeta(ABCMeta):
+    """
+    Metaclass for BasePhaseHook that automatically registers concrete
+    hook subclasses with the default_phase_hook_registry.
+    Registration uses the name obtained from the class method `get_name()`.
+    """
+    def __init__(cls, name, bases, dct):
+        super().__init__(name, bases, dct)
+
+        if name == 'BasePhaseHook' or getattr(cls, "__abstractmethods__", None):
+            logger.debug(f"Skipping registration for abstract phase hook class: {name}")
+            return
+
+        try:
+            hook_name = cls.get_name()
+
+            if not hook_name or not isinstance(hook_name, str):
+                logger.error(f"Phase hook class {name} must return a valid string from static get_name(). Skipping registration.")
+                return
+            
+            definition = PhaseHookDefinition(name=hook_name, hook_class=cls)
+            default_phase_hook_registry.register_hook(definition)
+            logger.info(f"Auto-registered phase hook: '{hook_name}' from class {name} (no schema).")
+
+        except AttributeError as e:
+            logger.error(f"Phase hook class {name} is missing required static/class method 'get_name' ({e}). Skipping registration.")
+        except Exception as e:
+            logger.error(f"Failed to auto-register phase hook class {name}: {e}", exc_info=True)

autobyteus/agent/hooks/hook_registry.py

@@ -0,0 +1,118 @@
+# file: autobyteus/autobyteus/agent/hooks/hook_registry.py
+import logging
+from typing import TYPE_CHECKING, Dict, List, Optional
+
+from autobyteus.utils.singleton import SingletonMeta
+from .hook_definition import PhaseHookDefinition
+
+if TYPE_CHECKING:
+    from .base_phase_hook import BasePhaseHook
+
+logger = logging.getLogger(__name__)
+
+class PhaseHookRegistry(metaclass=SingletonMeta):
+    """
+    A singleton registry for PhaseHookDefinition objects.
+    Hooks are typically auto-registered via PhaseHookMeta.
+    """
+
+    def __init__(self):
+        """Initializes the PhaseHookRegistry with an empty store."""
+        self._definitions: Dict[str, PhaseHookDefinition] = {}
+        logger.info("PhaseHookRegistry initialized.")
+
+    def register_hook(self, definition: PhaseHookDefinition) -> None:
+        """
+        Registers a phase hook definition.
+        If a definition with the same name already exists, it will be overwritten,
+        and a warning will be logged.
+
+        Args:
+            definition: The PhaseHookDefinition object to register.
+
+        Raises:
+            TypeError: If the definition is not an instance of PhaseHookDefinition.
+        """
+        if not isinstance(definition, PhaseHookDefinition):
+            raise TypeError(f"Expected PhaseHookDefinition instance, got {type(definition).__name__}.")
+
+        hook_name = definition.name
+        if hook_name in self._definitions:
+            logger.warning(f"Overwriting existing phase hook definition for name: '{hook_name}'.")
+        
+        self._definitions[hook_name] = definition
+        logger.info(f"Phase hook definition '{hook_name}' (class: '{definition.hook_class.__name__}') registered successfully.")
+
+    def get_hook_definition(self, name: str) -> Optional[PhaseHookDefinition]:
+        """
+        Retrieves a phase hook definition by its name.
+
+        Args:
+            name: The name of the phase hook definition to retrieve.
+
+        Returns:
+            The PhaseHookDefinition object if found, otherwise None.
+        """
+        if not isinstance(name, str):
+            logger.warning(f"Attempted to retrieve hook definition with non-string name: {type(name).__name__}.")
+            return None
+        definition = self._definitions.get(name)
+        if not definition:
+            logger.debug(f"Phase hook definition with name '{name}' not found in registry.")
+        return definition
+
+    def get_hook(self, name: str) -> Optional['BasePhaseHook']:
+        """
+        Retrieves an instance of a phase hook by its name.
+
+        Args:
+            name: The name of the phase hook to retrieve.
+
+        Returns:
+            An instance of the BasePhaseHook if found and instantiable, otherwise None.
+        """
+        definition = self.get_hook_definition(name)
+        if definition:
+            try:
+                return definition.hook_class()
+            except Exception as e:
+                logger.error(f"Failed to instantiate phase hook '{name}' from class '{definition.hook_class.__name__}': {e}", exc_info=True)
+                return None
+        return None
+
+    def list_hook_names(self) -> List[str]:
+        """
+        Returns a list of names of all registered phase hook definitions.
+
+        Returns:
+            A list of strings, where each string is a registered hook name.
+        """
+        return list(self._definitions.keys())
+
+    def get_all_definitions(self) -> Dict[str, PhaseHookDefinition]:
+        """
+        Returns a shallow copy of the dictionary containing all registered phase hook definitions.
+
+        Returns:
+            A dictionary where keys are hook names and values are PhaseHookDefinition objects.
+        """
+        return dict(self._definitions)
+
+    def clear(self) -> None:
+        """Removes all definitions from the registry."""
+        count = len(self._definitions)
+        self._definitions.clear()
+        logger.info(f"Cleared {count} definitions from the PhaseHookRegistry.")
+        
+    def __len__(self) -> int:
+        """Returns the number of registered hook definitions."""
+        return len(self._definitions)
+
+    def __contains__(self, name: str) -> bool:
+        """Checks if a hook definition is in the registry by name."""
+        if isinstance(name, str):
+            return name in self._definitions
+        return False
+
+# Default instance of the registry
+default_phase_hook_registry = PhaseHookRegistry()

autobyteus/agent/input_processor/base_user_input_processor.py

@@ -3,6 +3,8 @@ import logging
 from abc import ABC, abstractmethod
 from typing import TYPE_CHECKING, Optional
 
+from .processor_meta import AgentUserInputMessageProcessorMeta
+
 if TYPE_CHECKING:
     from autobyteus.agent.message.agent_input_user_message import AgentInputUserMessage 
     from autobyteus.agent.context import AgentContext # Composite AgentContext
@@ -10,7 +12,7 @@ if TYPE_CHECKING:
 
 logger = logging.getLogger(__name__)
 
-class BaseAgentUserInputMessageProcessor(ABC):
+class BaseAgentUserInputMessageProcessor(ABC, metaclass=AgentUserInputMessageProcessorMeta):
     """
     Abstract base class for agent user input message processors.
     These processors can modify an AgentInputUserMessage, specifically from a user,
@@ -18,12 +20,13 @@ class BaseAgentUserInputMessageProcessor(ABC):
     Subclasses should be instantiated and passed to the AgentSpecification.
     """
 
-    def get_name(self) -> str:
+    @classmethod
+    def get_name(cls) -> str:
         """
         Returns the unique registration name for this processor.
         Defaults to the class name. Can be overridden by subclasses.
         """
-        return self.__class__.__name__
+        return cls.__name__
 
     @abstractmethod
     async def process(self,

autobyteus/agent/input_processor/passthrough_input_processor.py

@@ -16,7 +16,8 @@ class PassthroughInputProcessor(BaseAgentUserInputMessageProcessor):
     A processor that returns the message unchanged.
     Can be used as a default or for testing.
     """
-    def get_name(self) -> str:
+    @classmethod
+    def get_name(cls) -> str:
         return "PassthroughInputProcessor"
 
     async def process(self,

autobyteus/agent/input_processor/processor_meta.py

@@ -37,7 +37,7 @@ class AgentUserInputMessageProcessorMeta(ABCMeta):
             # Create definition using name and the class itself
             definition = AgentUserInputMessageProcessorDefinition(name=processor_name, processor_class=cls)
             default_input_processor_registry.register_processor(definition)
-            logger.info(f"Auto-registered input processor: '{processor_name}' from class {name}")
+            logger.info(f"Auto-registered input processor: '{processor_name}' from class {name} (no schema).")
 
         except AttributeError as e:
             # Catch if get_name is missing

autobyteus/agent/input_processor/processor_registry.py

@@ -60,6 +60,25 @@ class AgentUserInputMessageProcessorRegistry(metaclass=SingletonMeta):
             logger.debug(f"Input processor definition with name '{name}' not found in registry.")
         return definition
 
+    def get_processor(self, name: str) -> Optional['BaseAgentUserInputMessageProcessor']:
+        """
+        Retrieves an instance of an input processor by its name.
+
+        Args:
+            name: The name of the input processor to retrieve.
+
+        Returns:
+            An instance of the BaseAgentUserInputMessageProcessor if found and instantiable, otherwise None.
+        """
+        definition = self.get_processor_definition(name)
+        if definition:
+            try:
+                return definition.processor_class()
+            except Exception as e:
+                logger.error(f"Failed to instantiate input processor '{name}' from class '{definition.processor_class.__name__}': {e}", exc_info=True)
+                return None
+        return None
+
     def list_processor_names(self) -> List[str]:
         """
         Returns a list of names of all registered input processor definitions.

autobyteus/agent/llm_response_processor/base_processor.py

@@ -3,6 +3,8 @@ import logging
 from abc import ABC, abstractmethod
 from typing import TYPE_CHECKING
 
+from .processor_meta import LLMResponseProcessorMeta
+
 if TYPE_CHECKING:
     from autobyteus.agent.context import AgentContext # MODIFIED IMPORT
     from autobyteus.agent.events import LLMCompleteResponseReceivedEvent
@@ -10,7 +12,7 @@ if TYPE_CHECKING:
 
 logger = logging.getLogger(__name__)
 
-class BaseLLMResponseProcessor(ABC):
+class BaseLLMResponseProcessor(ABC, metaclass=LLMResponseProcessorMeta):
     """
     Abstract base class for LLM response processors.
     These processors analyze the LLM's textual response. If they identify a specific
@@ -19,13 +21,14 @@ class BaseLLMResponseProcessor(ABC):
     Subclasses should be instantiated and passed to the AgentSpecification.
     """
 
-    def get_name(self) -> str:
+    @classmethod
+    def get_name(cls) -> str:
         """
         Returns the unique registration name for this processor.
         Defaults to the class name. Should be overridden by subclasses
         to provide a stable, user-friendly name (e.g., "xml_tool_usage").
         """
-        return self.__class__.__name__
+        return cls.__name__
 
     @abstractmethod
     async def process_response(self, response: 'CompleteResponse', context: 'AgentContext', triggering_event: 'LLMCompleteResponseReceivedEvent') -> bool:

autobyteus/agent/llm_response_processor/processor_meta.py

@@ -29,7 +29,7 @@ class LLMResponseProcessorMeta(ABCMeta):
             
             definition = LLMResponseProcessorDefinition(name=processor_name, processor_class=cls)
             default_llm_response_processor_registry.register_processor(definition)
-            logger.info(f"Auto-registered LLM response processor: '{processor_name}' from class {name}")
+            logger.info(f"Auto-registered LLM response processor: '{processor_name}' from class {name} (no schema).")
 
         except AttributeError as e:
             logger.error(f"LLM response processor class {name} is missing required static/class method 'get_name' ({e}). Skipping registration.")