autobyteus 1.1.3__py3-none-any.whl → 1.1.5__py3-none-any.whl

autobyteus/agent/message/send_message_to.py

@@ -1,150 +1,125 @@
-# file: autobyteus/autobyteus/agent/message/send_message_to.py
+# file: autobyteus/agent/message/send_message_to.py
 import logging
 from typing import TYPE_CHECKING, Any, Optional
 
-from autobyteus.agent.message.inter_agent_message import InterAgentMessage
 from autobyteus.tools.base_tool import BaseTool
-from autobyteus.agent.group.agent_group_context import AgentGroupContext
-# Updated imports for schema
+from autobyteus.tools.tool_category import ToolCategory
 from autobyteus.tools.parameter_schema import ParameterSchema, ParameterDefinition, ParameterType
-
+from autobyteus.tools.tool_config import ToolConfig
+# This import is for type hinting only and avoids circular dependencies at runtime
 if TYPE_CHECKING:
     from autobyteus.agent.context import AgentContext
-    from autobyteus.agent.agent import Agent 
+    from autobyteus.agent_team.context.agent_team_context import AgentTeamContext
+    from autobyteus.agent_team.context.team_manager import TeamManager
+    from autobyteus.agent_team.events.agent_team_events import InterAgentMessageRequestEvent
 
 logger = logging.getLogger(__name__)
 
 class SendMessageTo(BaseTool):
     """
-    A tool for sending messages to other agents within the same AgentGroup.
-    It utilizes AgentGroupContext injected into the calling agent's AgentContext
-    to resolve recipient agents.
+    A tool for sending messages to other agents within the same agent team.
+    This tool dynamically retrieves the team communication channel from the
+    agent's context at runtime.
     """
-    TOOL_NAME = "SendMessageTo" # Class attribute for the name
+    TOOL_NAME = "SendMessageTo"
+    CATEGORY = ToolCategory.AGENT_COMMUNICATION
+
+    def __init__(self, config: Optional[ToolConfig] = None):
+        """
+        Initializes the stateless SendMessageTo tool.
+        """
+        super().__init__(config=config)
+        # The TeamManager is no longer stored as an instance variable.
+        logger.debug("SendMessageTo tool initialized (stateless).")
 
-    def __init__(self):
-        super().__init__()
-        logger.debug(f"{self.get_name()} tool initialized.") # Use get_name()
+    # The set_team_manager method has been removed.
 
     @classmethod
-    def get_name(cls) -> str: # Implemented as per BaseTool requirement
+    def get_name(cls) -> str:
         return cls.TOOL_NAME
 
     @classmethod
     def get_description(cls) -> str:
-        return ("Sends a message to another agent within the same group. "
-                "Can target by role or specific agent ID.")
+        return ("Sends a message to another agent within the same team, starting them if necessary. "
+                "You must specify the recipient by their unique name as provided in your team manifest.")
 
     @classmethod
     def get_argument_schema(cls) -> Optional[ParameterSchema]:
         schema = ParameterSchema()
         schema.add_parameter(ParameterDefinition(
-            name="recipient_role_name",
+            name="recipient_name",
             param_type=ParameterType.STRING,
-            description="The general role name of the recipient agent (e.g., 'worker', 'reviewer').",
+            description='The unique name of the recipient agent (e.g., "Researcher", "Writer_1"). This MUST match a name from your team manifest.',
             required=True
         ))
         schema.add_parameter(ParameterDefinition(
             name="content",
             param_type=ParameterType.STRING,
-            description="The actual message text.",
+            description="The actual message content or task instruction.",
             required=True
         ))
         schema.add_parameter(ParameterDefinition(
             name="message_type",
-            param_type=ParameterType.STRING, # Or ENUM if InterAgentMessageType values are known and fixed for schema
+            param_type=ParameterType.STRING,
             description="Type of the message (e.g., TASK_ASSIGNMENT, CLARIFICATION). Custom types allowed.",
             required=True
         ))
-        schema.add_parameter(ParameterDefinition(
-            name="recipient_agent_id",
-            param_type=ParameterType.STRING,
-            description='Optional. Specific ID of the recipient agent. If "unknown" or omitted, resolves by role.',
-            required=False,
-            default_value=None # Explicitly no default, truly optional
-        ))
         return schema
 
-    # tool_usage_xml() and tool_usage_json() are inherited from BaseTool
-    # get_config_schema() for instantiation defaults to None
-
     async def _execute(self, 
                        context: 'AgentContext', 
-                       recipient_role_name: str, 
+                       recipient_name: str, 
                        content: str, 
-                       message_type: str, 
-                       recipient_agent_id: Optional[str] = None) -> str: # Named parameters
+                       message_type: str) -> str:
         """
-        Sends a message to another agent in the group.
-        Arguments are validated by BaseTool.execute().
+        Creates and dispatches an InterAgentMessageRequestEvent to the parent agent team
+        by retrieving the TeamManager from the agent's context.
         """
-        sender_agent_id = context.agent_id
-        logger.info(f"Tool '{self.get_name()}': Sender '{sender_agent_id}' attempting to send message. "
-                    f"Recipient Role: '{recipient_role_name}', Recipient ID: '{recipient_agent_id}', Type: '{message_type}'.")
-
-        group_context_any = context.custom_data.get('agent_group_context')
-        
-        if not isinstance(group_context_any, AgentGroupContext):
-            error_msg = f"Tool '{self.get_name()}' critical error: AgentGroupContext not found or invalid in AgentContext.custom_data for agent '{sender_agent_id}'. Cannot send message."
-            logger.error(error_msg)
+        # Local import to break circular dependency at module load time.
+        from autobyteus.agent_team.events.agent_team_events import InterAgentMessageRequestEvent
+
+        # --- NEW: Retrieve TeamManager dynamically from context ---
+        team_context: Optional['AgentTeamContext'] = context.custom_data.get("team_context")
+        if not team_context:
+            error_msg = "Critical error: SendMessageTo tool is not configured for team communication. It can only be used within a managed AgentTeam."
+            logger.error(f"Agent '{context.agent_id}': {error_msg}")
             return f"Error: {error_msg}"
         
-        group_context: AgentGroupContext = group_context_any # Type cast after check
-
-        target_agent: Optional['Agent'] = None
-
-        # Use recipient_agent_id if provided and not explicitly "unknown" (case-insensitive)
-        if recipient_agent_id and recipient_agent_id.lower() != "unknown":
-            target_agent = group_context.get_agent(recipient_agent_id)
-            if not target_agent:
-                logger.warning(f"Tool '{self.get_name()}': Agent with ID '{recipient_agent_id}' not found in group '{group_context.group_id}'. "
-                               f"Attempting to find by role '{recipient_role_name}'.")
-        
-        if not target_agent: 
-            agents_with_role = group_context.get_agents_by_role(recipient_role_name)
-            if not agents_with_role:
-                error_msg = f"No agent found with role '{recipient_role_name}' (and specific ID '{recipient_agent_id}' if provided was not found) in group '{group_context.group_id}'."
-                logger.error(f"Tool '{self.get_name()}': {error_msg}")
-                return f"Error: {error_msg}"
-            
-            if len(agents_with_role) > 1:
-                logger.warning(f"Tool '{self.get_name()}': Multiple agents ({len(agents_with_role)}) found for role '{recipient_role_name}'. "
-                               f"Sending to the first one: {agents_with_role[0].agent_id}. "
-                               "Consider using specific recipient_agent_id for clarity.")
-            target_agent = agents_with_role[0]
-            # Update recipient_agent_id to the one resolved by role if it was initially None or "unknown"
-            recipient_agent_id = target_agent.agent_id
-
-
-        if not target_agent: 
-            error_msg = f"Could not resolve recipient agent with role '{recipient_role_name}' or ID '{recipient_agent_id}'." # recipient_agent_id would be updated here
-            logger.error(f"Tool '{self.get_name()}': {error_msg}")
+        team_manager: Optional['TeamManager'] = team_context.team_manager
+        if not team_manager:
+            # This is an internal framework error and should not happen in a correctly configured team.
+            error_msg = "Internal Error: TeamManager not found in the provided team_context."
+            logger.error(f"Agent '{context.agent_id}': {error_msg}")
             return f"Error: {error_msg}"
 
-        try:
-            message_to_send = InterAgentMessage.create_with_dynamic_message_type(
-                recipient_role_name=target_agent.context.config.role, 
-                recipient_agent_id=target_agent.agent_id, # Use the definitively resolved agent ID
-                content=content,
-                message_type=message_type,
-                sender_agent_id=sender_agent_id
-            )
+        # --- Input Validation ---
+        if not isinstance(recipient_name, str) or not recipient_name.strip():
+            error_msg = "Error: `recipient_name` must be a non-empty string."
+            logger.error(f"Tool '{self.get_name()}' validation failed: {error_msg}")
+            return error_msg
+        if not isinstance(content, str) or not content.strip():
+            error_msg = "Error: `content` must be a non-empty string."
+            logger.error(f"Tool '{self.get_name()}' validation failed: {error_msg}")
+            return error_msg
+        if not isinstance(message_type, str) or not message_type.strip():
+            error_msg = "Error: `message_type` must be a non-empty string."
+            logger.error(f"Tool '{self.get_name()}' validation failed: {error_msg}")
+            return error_msg
             
-            await target_agent.post_inter_agent_message(message_to_send)
-            success_msg = (f"Message successfully sent from '{sender_agent_id}' to agent "
-                           f"'{target_agent.agent_id}' (Role: '{target_agent.context.config.role}').")
-            logger.info(f"Tool '{self.get_name()}': {success_msg}")
-            return success_msg
-        except ValueError as ve: 
-            error_msg = f"Error creating message: {str(ve)}"
-            logger.error(f"Tool '{self.get_name()}': {error_msg}", exc_info=True)
-            return f"Error: {error_msg}"
-        except Exception as e:
-            error_msg = f"An unexpected error occurred while sending message: {str(e)}"
-            logger.error(f"Tool '{self.get_name()}': {error_msg}", exc_info=True)
-            return f"Error: {error_msg}"
+        sender_agent_id = context.agent_id
+        logger.info(f"Tool '{self.get_name()}': Agent '{sender_agent_id}' requesting to send message to '{recipient_name}'.")
+
+        # Create the event for the agent team to handle
+        event = InterAgentMessageRequestEvent(
+            sender_agent_id=sender_agent_id,
+            recipient_name=recipient_name,
+            content=content,
+            message_type=message_type
+        )
+        
+        # Dispatch the event "up" to the team's event loop via the dynamically retrieved team manager
+        await team_manager.dispatch_inter_agent_message_request(event)
 
-    # tool_usage_xml was defined directly here, this is now inherited from BaseTool
-    # BaseTool.tool_usage_xml() will use get_argument_schema() to generate it.
-    # If a custom XML format was desired that differs from the auto-generated one,
-    # then this method could be overridden. For now, assume auto-generated is fine.
+        success_msg = f"Message dispatch for recipient '{recipient_name}' has been successfully requested."
+        logger.info(f"Tool '{self.get_name()}': {success_msg}")
+        return success_msg

autobyteus/agent/phases/discover.py

@@ -3,7 +3,8 @@ import inspect
 import logging
 from typing import List, Optional
 
-from autobyteus.agent.context.agent_phase_manager import AgentPhaseManager
+from autobyteus.agent.phases.manager import AgentPhaseManager
+
 from .transition_info import PhaseTransitionInfo
 
 logger = logging.getLogger(__name__)

autobyteus/agent/runtime/agent_runtime.py

@@ -5,7 +5,7 @@ import traceback
 import concurrent.futures 
 from typing import Optional, Any, Callable, Awaitable, TYPE_CHECKING 
 
-from autobyteus.agent.context import AgentContext 
+from autobyteus.agent.context import AgentContext, AgentContextRegistry
 from autobyteus.agent.phases import AgentOperationalPhase, AgentPhaseManager 
 from autobyteus.agent.events.notifiers import AgentExternalEventNotifier 
 from autobyteus.agent.events import BaseEvent
@@ -39,8 +39,12 @@ class AgentRuntime:
             event_handler_registry=self.event_handler_registry,
         )
         self._worker.add_done_callback(self._handle_worker_completion)
+        
+        # Register the context with the global registry
+        self._context_registry = AgentContextRegistry()
+        self._context_registry.register_context(self.context)
 
-        logger.info(f"AgentRuntime initialized for agent_id '{self.context.agent_id}'.")
+        logger.info(f"AgentRuntime initialized for agent_id '{self.context.agent_id}'. Context registered.")
 
     def get_worker_loop(self) -> Optional[asyncio.AbstractEventLoop]:
         return self._worker.get_worker_loop()
@@ -122,6 +126,10 @@ class AgentRuntime:
         
         # LLM instance cleanup is now handled by the AgentWorker before its loop closes.
         
+        # Unregister the context from the global registry
+        self._context_registry.unregister_context(agent_id)
+        logger.info(f"AgentRuntime for '{agent_id}': Context unregistered.")
+
         await self.phase_manager.notify_final_shutdown_complete() 
         logger.info(f"AgentRuntime for '{agent_id}' stop() method completed.")
 

autobyteus/agent/runtime/agent_worker.py

@@ -221,6 +221,7 @@ class AgentWorker:
         # Wait for the main thread future to complete.
         if self._thread_future:
             try:
+                # FIX: Use asyncio.wait_for() to handle the timeout correctly.
                 await asyncio.wait_for(asyncio.wrap_future(self._thread_future), timeout=timeout)
                 logger.info(f"AgentWorker '{agent_id}': Worker thread has terminated.")
             except asyncio.TimeoutError:

autobyteus/agent/sender_type.py

@@ -0,0 +1,15 @@
+# file: autobyteus/autobyteus/agent/sender_type.py
+from enum import Enum
+from typing import Set
+
+class SenderType(str, Enum):
+    """
+    Categorizes the origin of a message or event within the system.
+    """
+    USER = "user"        # A message originating from an external human user.
+    AGENT = "agent"      # A message from another agent within the same team or a different team.
+    SYSTEM = "system"    # An automated message from an internal system component.
+
+
+# --- System Sender Identification ---
+TASK_NOTIFIER_SENDER_ID = "system.task_notifier"

autobyteus/agent/streaming/agent_event_stream.py

@@ -16,6 +16,7 @@ from autobyteus.agent.streaming.stream_event_payloads import (
     create_error_event_data,
     create_tool_invocation_approval_requested_data,
     create_tool_invocation_auto_executing_data,
+    create_system_task_notification_data, # NEW
     AssistantChunkData,
     AssistantCompleteResponseData,
     ToolInteractionLogEntryData,
@@ -23,6 +24,7 @@ from autobyteus.agent.streaming.stream_event_payloads import (
     ToolInvocationApprovalRequestedData,
     ToolInvocationAutoExecutingData,
     ErrorEventData,
+    SystemTaskNotificationData, # NEW
     EmptyData,
     StreamDataPayload,
 )
@@ -101,6 +103,10 @@ class AgentEventStream(EventEmitter):
             elif event_type == EventType.AGENT_ERROR_OUTPUT_GENERATION:
                 typed_payload_for_stream_event = create_error_event_data(payload)
                 stream_event_type_for_generic_stream = StreamEventType.ERROR_EVENT
+            # NEW MAPPING
+            elif event_type == EventType.AGENT_DATA_SYSTEM_TASK_NOTIFICATION_RECEIVED:
+                typed_payload_for_stream_event = create_system_task_notification_data(payload)
+                stream_event_type_for_generic_stream = StreamEventType.SYSTEM_TASK_NOTIFICATION
             
             elif event_type in [EventType.AGENT_DATA_ASSISTANT_CHUNK_STREAM_END, EventType.AGENT_DATA_TOOL_LOG_STREAM_END]:
                  pass 

autobyteus/agent/streaming/stream_event_payloads.py

@@ -55,6 +55,11 @@ class ToolInvocationAutoExecutingData(BaseStreamPayload):
     tool_name: str
     arguments: Dict[str, Any]
 
+# NEW PAYLOAD
+class SystemTaskNotificationData(BaseStreamPayload):
+    sender_id: str
+    content: str
+
 class EmptyData(BaseStreamPayload):
     pass
 
@@ -67,6 +72,7 @@ StreamDataPayload = Union[
     ErrorEventData,
     ToolInvocationApprovalRequestedData,
     ToolInvocationAutoExecutingData,
+    SystemTaskNotificationData, # NEW
     EmptyData
 ]
 
@@ -165,3 +171,9 @@ def create_tool_invocation_auto_executing_data(auto_exec_data_dict: Any) -> Tool
     if isinstance(auto_exec_data_dict, dict):
         return ToolInvocationAutoExecutingData(**auto_exec_data_dict)
     raise ValueError(f"Cannot create ToolInvocationAutoExecutingData from {type(auto_exec_data_dict)}")
+
+# NEW FACTORY FUNCTION
+def create_system_task_notification_data(notification_data_dict: Any) -> SystemTaskNotificationData:
+    if isinstance(notification_data_dict, dict):
+        return SystemTaskNotificationData(**notification_data_dict)
+    raise ValueError(f"Cannot create SystemTaskNotificationData from {type(notification_data_dict)}")

autobyteus/agent/streaming/stream_events.py

@@ -16,6 +16,7 @@ from .stream_event_payloads import (
     ErrorEventData,
     ToolInvocationApprovalRequestedData,
     ToolInvocationAutoExecutingData,
+    SystemTaskNotificationData, # NEW
     EmptyData
 )
 
@@ -33,6 +34,7 @@ class StreamEventType(str, Enum):
     ERROR_EVENT = "error_event" 
     TOOL_INVOCATION_APPROVAL_REQUESTED = "tool_invocation_approval_requested" 
     TOOL_INVOCATION_AUTO_EXECUTING = "tool_invocation_auto_executing"
+    SYSTEM_TASK_NOTIFICATION = "system_task_notification" # NEW
     AGENT_IDLE = "agent_idle"
 
 
@@ -44,6 +46,7 @@ _STREAM_EVENT_TYPE_TO_PAYLOAD_CLASS: Dict[StreamEventType, Type[BaseModel]] = {
     StreamEventType.ERROR_EVENT: ErrorEventData,
     StreamEventType.TOOL_INVOCATION_APPROVAL_REQUESTED: ToolInvocationApprovalRequestedData,
     StreamEventType.TOOL_INVOCATION_AUTO_EXECUTING: ToolInvocationAutoExecutingData,
+    StreamEventType.SYSTEM_TASK_NOTIFICATION: SystemTaskNotificationData, # NEW
     StreamEventType.AGENT_IDLE: AgentOperationalPhaseTransitionData,
 }
 

autobyteus/agent/system_prompt_processor/tool_manifest_injector_processor.py

@@ -6,6 +6,7 @@ from .base_processor import BaseSystemPromptProcessor
 from autobyteus.tools.registry import default_tool_registry, ToolDefinition
 from autobyteus.tools.usage.providers import ToolManifestProvider
 from autobyteus.prompt.prompt_template import PromptTemplate
+from autobyteus.llm.providers import LLMProvider
 
 if TYPE_CHECKING:
     from autobyteus.tools.base_tool import BaseTool
@@ -18,6 +19,7 @@ class ToolManifestInjectorProcessor(BaseSystemPromptProcessor):
     Injects a tool manifest into the system prompt using Jinja2-style placeholders.
     It primarily targets the '{{tools}}' variable. It uses PromptTemplate for
     rendering and delegates manifest generation to a ToolManifestProvider.
+    It automatically determines whether to use XML or JSON based on the LLM provider.
     """
     # The '{{tools}}' placeholder is now handled by Jinja2 via PromptTemplate.
     DEFAULT_PREFIX_FOR_TOOLS_ONLY_PROMPT = "You have access to a set of tools. Use them by outputting the appropriate tool call format. The user can only see the output of the tool, not the call itself. The available tools are:\n\n"
@@ -42,6 +44,10 @@ class ToolManifestInjectorProcessor(BaseSystemPromptProcessor):
         if "tools" not in prompt_template.required_vars:
             return system_prompt
 
+        llm_provider = None
+        if context.llm_instance and context.llm_instance.model:
+            llm_provider = context.llm_instance.model.provider
+
         # Generate the manifest string for the 'tools' variable.
         tools_manifest: str
         if not tool_instances:
@@ -52,13 +58,10 @@ class ToolManifestInjectorProcessor(BaseSystemPromptProcessor):
                 td for name in tool_instances if (td := default_tool_registry.get_tool_definition(name))
             ]
 
-            llm_provider = context.llm_instance.model.provider if context.llm_instance and context.llm_instance.model else None
-
             try:
-                # Delegate manifest generation to the provider
+                # Delegate manifest generation to the provider, which now handles all format logic.
                 tools_manifest = self._manifest_provider.provide(
                     tool_definitions=tool_definitions,
-                    use_xml=context.config.use_xml_tool_format,
                     provider=llm_provider
                 )
             except Exception as e:

autobyteus/agent/tool_execution_result_processor/__init__.py

@@ -0,0 +1,9 @@
+# file: autobyteus/autobyteus/agent/tool_execution_result_processor/__init__.py
+"""
+Components for processing tool execution results before they are sent to the LLM.
+"""
+from .base_processor import BaseToolExecutionResultProcessor
+
+__all__ = [
+    "BaseToolExecutionResultProcessor",
+]

autobyteus/agent/tool_execution_result_processor/base_processor.py

@@ -0,0 +1,46 @@
+# file: autobyteus/autobyteus/agent/tool_execution_result_processor/base_processor.py
+import logging
+from abc import ABC, abstractmethod
+from typing import TYPE_CHECKING
+
+from .processor_meta import ToolExecutionResultProcessorMeta
+
+if TYPE_CHECKING:
+    from autobyteus.agent.context import AgentContext
+    from autobyteus.agent.events import ToolResultEvent
+
+logger = logging.getLogger(__name__)
+
+class BaseToolExecutionResultProcessor(ABC, metaclass=ToolExecutionResultProcessorMeta):
+    """
+    Abstract base class for processors that can modify a tool's execution result.
+    These processors are applied after a tool runs but before its result is formatted
+    for the LLM.
+    """
+
+    @classmethod
+    def get_name(cls) -> str:
+        """
+        Returns the unique registration name for this processor.
+        Defaults to the class name.
+        """
+        return cls.__name__
+
+    @abstractmethod
+    async def process(self,
+                      event: 'ToolResultEvent',
+                      context: 'AgentContext') -> 'ToolResultEvent':
+        """
+        Processes the given ToolResultEvent.
+
+        Args:
+            event: The ToolResultEvent containing the tool's output or error.
+            context: The agent's context, providing access to config and state.
+
+        Returns:
+            The processed (potentially modified) ToolResultEvent.
+        """
+        raise NotImplementedError("Subclasses must implement the 'process' method.")
+
+    def __repr__(self) -> str:
+        return f"<{self.__class__.__name__}>"

autobyteus/agent/tool_execution_result_processor/processor_definition.py

@@ -0,0 +1,36 @@
+# file: autobyteus/autobyteus/agent/tool_execution_result_processor/processor_definition.py
+import logging
+from typing import Type, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from .base_processor import BaseToolExecutionResultProcessor
+
+logger = logging.getLogger(__name__)
+
+class ToolExecutionResultProcessorDefinition:
+    """
+    Represents the definition of a tool execution result processor.
+    Contains its registered name and the class itself.
+    """
+    def __init__(self, name: str, processor_class: Type['BaseToolExecutionResultProcessor']):
+        """
+        Initializes the ToolExecutionResultProcessorDefinition.
+
+        Args:
+            name: The unique registered name of the processor.
+            processor_class: The class of the tool execution result processor.
+
+        Raises:
+            ValueError: If name is empty or processor_class is not a type.
+        """
+        if not name or not isinstance(name, str):
+            raise ValueError("Tool Execution Result Processor name must be a non-empty string.")
+        if not isinstance(processor_class, type):
+            raise ValueError("processor_class must be a class type.")
+        
+        self.name: str = name
+        self.processor_class: Type['BaseToolExecutionResultProcessor'] = processor_class
+        logger.debug(f"ToolExecutionResultProcessorDefinition created: name='{name}', class='{processor_class.__name__}'.")
+
+    def __repr__(self) -> str:
+        return f"<ToolExecutionResultProcessorDefinition name='{self.name}', class='{self.processor_class.__name__}'>"

autobyteus/agent/tool_execution_result_processor/processor_meta.py

@@ -0,0 +1,36 @@
+# file: autobyteus/autobyteus/agent/tool_execution_result_processor/processor_meta.py
+import logging
+from abc import ABCMeta
+
+from .processor_registry import default_tool_execution_result_processor_registry
+from .processor_definition import ToolExecutionResultProcessorDefinition
+
+logger = logging.getLogger(__name__)
+
+class ToolExecutionResultProcessorMeta(ABCMeta):
+    """
+    Metaclass for BaseToolExecutionResultProcessor that automatically registers
+    concrete processor subclasses with the default registry.
+    """
+    def __init__(cls, name, bases, dct):
+        super().__init__(name, bases, dct)
+
+        if name == 'BaseToolExecutionResultProcessor' or getattr(cls, "__abstractmethods__", None):
+            logger.debug(f"Skipping registration for abstract tool execution result processor class: {name}")
+            return
+
+        try:
+            processor_name = cls.get_name()
+
+            if not processor_name or not isinstance(processor_name, str):
+                logger.error(f"Tool execution result processor class {name} must return a valid string from get_name(). Skipping.")
+                return
+            
+            definition = ToolExecutionResultProcessorDefinition(name=processor_name, processor_class=cls)
+            default_tool_execution_result_processor_registry.register_processor(definition)
+            logger.info(f"Auto-registered tool execution result processor: '{processor_name}' from class {name}.")
+
+        except AttributeError as e:
+            logger.error(f"Tool execution result processor class {name} is missing 'get_name' method ({e}). Skipping registration.")
+        except Exception as e:
+            logger.error(f"Failed to auto-register tool execution result processor class {name}: {e}", exc_info=True)

autobyteus/agent/tool_execution_result_processor/processor_registry.py

@@ -0,0 +1,70 @@
+# file: autobyteus/autobyteus/agent/tool_execution_result_processor/processor_registry.py
+import logging
+from typing import TYPE_CHECKING, Dict, List, Optional
+
+from autobyteus.utils.singleton import SingletonMeta
+from .processor_definition import ToolExecutionResultProcessorDefinition
+
+if TYPE_CHECKING:
+    from .base_processor import BaseToolExecutionResultProcessor
+
+logger = logging.getLogger(__name__)
+
+class ToolExecutionResultProcessorRegistry(metaclass=SingletonMeta):
+    """
+    A singleton registry for ToolExecutionResultProcessorDefinition objects.
+    Processors are typically auto-registered via ToolExecutionResultProcessorMeta.
+    """
+
+    def __init__(self):
+        """Initializes the registry with an empty store."""
+        self._definitions: Dict[str, ToolExecutionResultProcessorDefinition] = {}
+        logger.info("ToolExecutionResultProcessorRegistry initialized.")
+
+    def register_processor(self, definition: ToolExecutionResultProcessorDefinition) -> None:
+        """
+        Registers a tool execution result processor definition.
+        """
+        if not isinstance(definition, ToolExecutionResultProcessorDefinition):
+            raise TypeError(f"Expected ToolExecutionResultProcessorDefinition instance, got {type(definition).__name__}.")
+
+        processor_name = definition.name
+        if processor_name in self._definitions:
+            logger.warning(f"Overwriting existing tool execution result processor definition for name: '{processor_name}'.")
+        
+        self._definitions[processor_name] = definition
+        logger.info(f"Tool execution result processor definition '{processor_name}' registered successfully.")
+
+    def get_processor_definition(self, name: str) -> Optional[ToolExecutionResultProcessorDefinition]:
+        """
+        Retrieves a processor definition by its name.
+        """
+        return self._definitions.get(name)
+
+    def get_processor(self, name: str) -> Optional['BaseToolExecutionResultProcessor']:
+        """
+        Retrieves an instance of a processor by its name.
+        """
+        definition = self.get_processor_definition(name)
+        if definition:
+            try:
+                return definition.processor_class()
+            except Exception as e:
+                logger.error(f"Failed to instantiate tool execution result processor '{name}': {e}", exc_info=True)
+                return None
+        return None
+
+    def list_processor_names(self) -> List[str]:
+        """
+        Returns a list of names of all registered processor definitions.
+        """
+        return list(self._definitions.keys())
+
+    def get_all_definitions(self) -> Dict[str, ToolExecutionResultProcessorDefinition]:
+        """
+        Returns a dictionary of all registered processor definitions.
+        """
+        return dict(self._definitions)
+
+# Default instance of the registry
+default_tool_execution_result_processor_registry = ToolExecutionResultProcessorRegistry()