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

autobyteus/agent/agent.py

@@ -4,7 +4,7 @@ import logging
 from typing import AsyncIterator, Optional, List, Any, Dict, TYPE_CHECKING 
 
 from autobyteus.agent.runtime.agent_runtime import AgentRuntime
-from autobyteus.agent.context.phases import AgentOperationalPhase 
+from autobyteus.agent.phases.phase_enum import AgentOperationalPhase 
 from autobyteus.agent.message.agent_input_user_message import AgentInputUserMessage
 from autobyteus.agent.message.inter_agent_message import InterAgentMessage
 from autobyteus.agent.events import UserMessageReceivedEvent, InterAgentMessageReceivedEvent, ToolExecutionApprovalEvent, BaseEvent 

autobyteus/agent/bootstrap_steps/system_prompt_processing_step.py

@@ -34,8 +34,10 @@ class SystemPromptProcessingStep(BaseBootstrapStep):
             if not llm_instance:
                 raise ValueError("LLM instance not found in agent state. It must be provided in AgentConfig.")
 
-            current_system_prompt = context.config.system_prompt
-            logger.debug(f"Agent '{agent_id}': Retrieved base system prompt from agent config.")
+            # If a specific system_prompt is not provided in AgentConfig, fall back
+            # to the default system_message from the LLM's own configuration.
+            current_system_prompt = context.config.system_prompt or llm_instance.config.system_message
+            logger.debug(f"Agent '{agent_id}': Retrieved base system prompt.")
             
             processor_instances = context.config.system_prompt_processors
             tool_instances_for_processor = context.tool_instances

autobyteus/agent/context/agent_config.py

@@ -1,5 +1,6 @@
 # file: autobyteus/autobyteus/agent/context/agent_config.py
 import logging
+import copy
 from typing import List, Optional, Union, Tuple, TYPE_CHECKING, Dict, Any
 
 # Correctly import the new master processor and the base class
@@ -10,6 +11,7 @@ from autobyteus.agent.llm_response_processor import ProviderAwareToolUsageProces
 if TYPE_CHECKING:
     from autobyteus.tools.base_tool import BaseTool
     from autobyteus.agent.input_processor import BaseAgentUserInputMessageProcessor
+    from autobyteus.agent.tool_execution_result_processor import BaseToolExecutionResultProcessor
     from autobyteus.llm.base_llm import BaseLLM
     from autobyteus.agent.workspace.base_workspace import BaseAgentWorkspace
     from autobyteus.agent.hooks.base_phase_hook import BasePhaseHook
@@ -32,13 +34,14 @@ class AgentConfig:
                  role: str,
                  description: str,
                  llm_instance: 'BaseLLM',
-                 system_prompt: str,
-                 tools: List['BaseTool'],
+                 system_prompt: Optional[str] = None,
+                 tools: Optional[List['BaseTool']] = None,
                  auto_execute_tools: bool = True,
                  use_xml_tool_format: bool = True,
                  input_processors: Optional[List['BaseAgentUserInputMessageProcessor']] = None,
                  llm_response_processors: Optional[List['BaseLLMResponseProcessor']] = None,
                  system_prompt_processors: Optional[List['BaseSystemPromptProcessor']] = None,
+                 tool_execution_result_processors: Optional[List['BaseToolExecutionResultProcessor']] = None,
                  workspace: Optional['BaseAgentWorkspace'] = None,
                  phase_hooks: Optional[List['BasePhaseHook']] = None,
                  initial_custom_data: Optional[Dict[str, Any]] = None):
@@ -51,13 +54,15 @@ class AgentConfig:
             description: A description of the agent.
             llm_instance: A pre-initialized LLM instance (subclass of BaseLLM).
                           The user is responsible for creating and configuring this instance.
-            system_prompt: The base system prompt.
-            tools: A list of pre-initialized tool instances (subclasses of BaseTool).
+            system_prompt: The base system prompt. If None, the system_message from the
+                           llm_instance's config will be used as the base.
+            tools: An optional list of pre-initialized tool instances (subclasses of BaseTool).
             auto_execute_tools: If True, the agent will execute tools without approval.
             use_xml_tool_format: Whether to use XML for tool descriptions and examples.
             input_processors: A list of input processor instances.
             llm_response_processors: A list of LLM response processor instances.
             system_prompt_processors: A list of system prompt processor instances.
+            tool_execution_result_processors: A list of tool execution result processor instances.
             workspace: An optional pre-initialized workspace instance for the agent.
             phase_hooks: An optional list of phase transition hook instances.
             initial_custom_data: An optional dictionary of data to pre-populate
@@ -68,17 +73,43 @@ class AgentConfig:
         self.description = description
         self.llm_instance = llm_instance
         self.system_prompt = system_prompt
-        self.tools = tools
+        self.tools = tools or []
         self.workspace = workspace
         self.auto_execute_tools = auto_execute_tools
         self.use_xml_tool_format = use_xml_tool_format
         self.input_processors = input_processors or []
         self.llm_response_processors = llm_response_processors if llm_response_processors is not None else list(self.DEFAULT_LLM_RESPONSE_PROCESSORS)
         self.system_prompt_processors = system_prompt_processors if system_prompt_processors is not None else list(self.DEFAULT_SYSTEM_PROMPT_PROCESSORS)
+        self.tool_execution_result_processors = tool_execution_result_processors or []
         self.phase_hooks = phase_hooks or []
         self.initial_custom_data = initial_custom_data
 
         logger.debug(f"AgentConfig created for name '{self.name}', role '{self.role}'.")
 
+    def copy(self) -> 'AgentConfig':
+        """
+        Creates a copy of this AgentConfig. It avoids deep-copying complex objects
+        like tools, workspaces, and processors that may contain un-pickleable state.
+        Instead, it creates shallow copies of the lists, allowing the lists themselves
+        to be modified independently while sharing the object instances within them.
+        """
+        return AgentConfig(
+            name=self.name,
+            role=self.role,
+            description=self.description,
+            llm_instance=self.llm_instance,  # Keep reference, do not copy
+            system_prompt=self.system_prompt,
+            tools=self.tools.copy(),  # Shallow copy the list, but reference the original tool instances
+            auto_execute_tools=self.auto_execute_tools,
+            use_xml_tool_format=self.use_xml_tool_format,
+            input_processors=self.input_processors.copy(), # Shallow copy the list
+            llm_response_processors=self.llm_response_processors.copy(), # Shallow copy the list
+            system_prompt_processors=self.system_prompt_processors.copy(), # Shallow copy the list
+            tool_execution_result_processors=self.tool_execution_result_processors.copy(), # Shallow copy the list
+            workspace=self.workspace,  # Pass by reference, do not copy
+            phase_hooks=self.phase_hooks.copy(), # Shallow copy the list
+            initial_custom_data=copy.deepcopy(self.initial_custom_data) # Deep copy for simple data
+        )
+
     def __repr__(self) -> str:
         return (f"AgentConfig(name='{self.name}', role='{self.role}', llm_instance='{self.llm_instance.__class__.__name__}', workspace_configured={self.workspace is not None})")

autobyteus/agent/events/worker_event_dispatcher.py

@@ -21,8 +21,7 @@ from autobyteus.agent.events.agent_events import ( # Updated relative import pat
 if TYPE_CHECKING:
     from autobyteus.agent.context import AgentContext
     from autobyteus.agent.handlers import EventHandlerRegistry
-    from autobyteus.agent.context.agent_phase_manager import AgentPhaseManager
-
+    from autobyteus.agent.phases import AgentPhaseManager
 logger = logging.getLogger(__name__)
 
 class WorkerEventDispatcher:

autobyteus/agent/handlers/inter_agent_message_event_handler.py

@@ -43,7 +43,7 @@ class InterAgentMessageReceivedEventHandler(AgentEventHandler):
         logger.info(
             f"Agent '{context.agent_id}' handling InterAgentMessageReceivedEvent from sender "
             f"'{inter_agent_msg.sender_agent_id}', type '{inter_agent_msg.message_type.value}'. "
-            f"Content: '{inter_agent_msg.content[:100]}...'"
+            f"Content: '{inter_agent_msg.content}'"
         )
 
         content_for_llm = (

autobyteus/agent/handlers/llm_user_message_ready_event_handler.py

@@ -45,7 +45,7 @@ class LLMUserMessageReadyEventHandler(AgentEventHandler):
             raise RuntimeError(error_msg) 
 
         llm_user_message: LLMUserMessage = event.llm_user_message
-        logger.info(f"Agent '{agent_id}' handling LLMUserMessageReadyEvent: '{llm_user_message.content[:100]}...'") 
+        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})
@@ -137,4 +137,4 @@ class LLMUserMessageReadyEventHandler(AgentEventHandler):
             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.")
+        logger.info(f"Agent '{agent_id}' enqueued LLMCompleteResponseReceivedEvent from LLMUserMessageReadyEventHandler.")

autobyteus/agent/handlers/tool_result_event_handler.py

@@ -6,6 +6,7 @@ from typing import TYPE_CHECKING, Optional
 from autobyteus.agent.handlers.base_event_handler import AgentEventHandler 
 from autobyteus.agent.events import ToolResultEvent, LLMUserMessageReadyEvent 
 from autobyteus.llm.user_message import LLMUserMessage 
+from autobyteus.agent.tool_execution_result_processor import BaseToolExecutionResultProcessor
 
 if TYPE_CHECKING:
     from autobyteus.agent.context import AgentContext 
@@ -29,10 +30,37 @@ class ToolResultEventHandler(AgentEventHandler):
             logger.warning(f"ToolResultEventHandler received non-ToolResultEvent: {type(event)}. Skipping.")
             return
 
-        agent_id = context.agent_id 
-        tool_invocation_id = event.tool_invocation_id if event.tool_invocation_id else 'N/A'
+        agent_id = context.agent_id
+        processed_event = event
 
-        logger.info(f"Agent '{agent_id}' handling ToolResultEvent from tool: '{event.tool_name}' (Invocation ID: {tool_invocation_id}). Error: {event.error is not None}")
+        # --- New: Apply Tool Execution Result Processors ---
+        processor_instances = context.config.tool_execution_result_processors
+        if processor_instances:
+            processor_names = [p.get_name() for p in processor_instances]
+            logger.debug(f"Agent '{agent_id}': Applying tool execution result processors: {processor_names}")
+            for processor_instance in processor_instances:
+                processor_name_for_log = "unknown"
+                try:
+                    if not isinstance(processor_instance, BaseToolExecutionResultProcessor):
+                        logger.error(f"Agent '{agent_id}': Invalid tool result processor type: {type(processor_instance)}. Skipping.")
+                        continue
+                    
+                    processor_name_for_log = processor_instance.get_name()
+                    logger.debug(f"Agent '{agent_id}': Applying tool result processor '{processor_name_for_log}'.")
+                    
+                    event_before_proc = processed_event
+                    processed_event = await processor_instance.process(event_before_proc, context)
+                    logger.info(f"Agent '{agent_id}': Tool result processor '{processor_name_for_log}' applied successfully.")
+
+                except Exception as e:
+                    logger.error(f"Agent '{agent_id}': Error applying tool result processor '{processor_name_for_log}': {e}. "
+                                 f"Skipping and continuing with result from before this processor.", exc_info=True)
+                    processed_event = event_before_proc
+        # --- End New ---
+
+        tool_invocation_id = processed_event.tool_invocation_id if processed_event.tool_invocation_id else 'N/A'
+
+        logger.info(f"Agent '{agent_id}' handling processed ToolResultEvent from tool: '{processed_event.tool_name}' (Invocation ID: {tool_invocation_id}). Error: {processed_event.error is not None}")
         
         notifier: Optional['AgentExternalEventNotifier'] = None
         if context.phase_manager:
@@ -41,61 +69,61 @@ class ToolResultEventHandler(AgentEventHandler):
         if not notifier: # pragma: no cover
             logger.error(f"Agent '{agent_id}': Notifier not available in ToolResultEventHandler. Tool result processing logs will not be emitted.")
 
-        if event.error:
-            logger.debug(f"Agent '{agent_id}' tool '{event.tool_name}' (ID: {tool_invocation_id}) raw error details: {event.error}")
+        if processed_event.error:
+            logger.debug(f"Agent '{agent_id}' tool '{processed_event.tool_name}' (ID: {tool_invocation_id}) raw error details: {processed_event.error}")
         else:
             try:
-                raw_result_str_for_debug_log = json.dumps(event.result, indent=2)
+                raw_result_str_for_debug_log = json.dumps(processed_event.result, indent=2)
             except TypeError: # pragma: no cover
-                raw_result_str_for_debug_log = str(event.result)
-            logger.debug(f"Agent '{agent_id}' tool '{event.tool_name}' (ID: {tool_invocation_id}) raw result:\n---\n{raw_result_str_for_debug_log}\n---")
+                raw_result_str_for_debug_log = str(processed_event.result)
+            logger.debug(f"Agent '{agent_id}' tool '{processed_event.tool_name}' (ID: {tool_invocation_id}) raw result:\n---\n{raw_result_str_for_debug_log}\n---")
 
 
         content_for_llm: str
-        if event.error:
+        if processed_event.error:
             content_for_llm = (
-                f"The tool '{event.tool_name}' (invocation ID: {tool_invocation_id}) encountered an error.\n"
-                f"Error details: {event.error}\n"
+                f"The tool '{processed_event.tool_name}' (invocation ID: {tool_invocation_id}) encountered an error.\n"
+                f"Error details: {processed_event.error}\n"
                 f"Please analyze this error and decide the next course of action."
             )
-            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}"
+            log_msg_error_processed = f"[TOOL_RESULT_ERROR_PROCESSED] Agent_ID: {agent_id}, Tool: {processed_event.tool_name}, Invocation_ID: {tool_invocation_id}, Error: {processed_event.error}"
             if notifier:
                 try:
                     log_data = {
                         "log_entry": log_msg_error_processed,
                         "tool_invocation_id": tool_invocation_id,
-                        "tool_name": event.tool_name,
+                        "tool_name": processed_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:
             try:
-                result_str_for_llm = json.dumps(event.result, indent=2) if not isinstance(event.result, str) else event.result
+                result_str_for_llm = json.dumps(processed_event.result, indent=2) if not isinstance(processed_event.result, str) else processed_event.result
             except TypeError: # pragma: no cover
-                result_str_for_llm = str(event.result)
+                result_str_for_llm = str(processed_event.result)
 
             content_for_llm = (
-                f"The tool '{event.tool_name}' (invocation ID: {tool_invocation_id}) has executed.\n"
+                f"The tool '{processed_event.tool_name}' (invocation ID: {tool_invocation_id}) has executed.\n"
                 f"Result:\n{result_str_for_llm}\n" 
                 f"Based on this result, what is the next step or final answer?"
             )
-            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]}"
+            log_msg_success_processed = f"[TOOL_RESULT_SUCCESS_PROCESSED] Agent_ID: {agent_id}, Tool: {processed_event.tool_name}, Invocation_ID: {tool_invocation_id}, Result: {str(processed_event.result)}"
             if notifier:
                 try:
                     log_data = {
                         "log_entry": log_msg_success_processed,
                         "tool_invocation_id": tool_invocation_id,
-                        "tool_name": event.tool_name,
+                        "tool_name": processed_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)
         
-        logger.debug(f"Agent '{agent_id}' preparing message for LLM based on tool '{event.tool_name}' (ID: {tool_invocation_id}) result:\n---\n{content_for_llm}\n---")
+        logger.debug(f"Agent '{agent_id}' preparing message for LLM based on tool '{processed_event.tool_name}' (ID: {tool_invocation_id}) result:\n---\n{content_for_llm}\n---")
         llm_user_message = LLMUserMessage(content=content_for_llm)
         
         next_event = LLMUserMessageReadyEvent(llm_user_message=llm_user_message) 
         await context.input_event_queues.enqueue_internal_system_event(next_event)
         
-        logger.info(f"Agent '{agent_id}' enqueued LLMUserMessageReadyEvent for LLM based on tool '{event.tool_name}' (ID: {tool_invocation_id}) result summary.") 
+        logger.info(f"Agent '{agent_id}' enqueued LLMUserMessageReadyEvent for LLM based on tool '{processed_event.tool_name}' (ID: {tool_invocation_id}) result summary.")

autobyteus/agent/handlers/user_input_message_event_handler.py

@@ -35,7 +35,7 @@ class UserInputMessageEventHandler(AgentEventHandler):
         original_agent_input_user_msg: AgentInputUserMessage = event.agent_input_user_message 
         processed_agent_input_user_msg: AgentInputUserMessage = original_agent_input_user_msg 
         
-        logger.info(f"Agent '{context.agent_id}' handling UserMessageReceivedEvent: '{original_agent_input_user_msg.content[:100]}...'") 
+        logger.info(f"Agent '{context.agent_id}' handling UserMessageReceivedEvent: '{original_agent_input_user_msg.content}'") 
         
         processor_instances = context.config.input_processors
         if processor_instances:

autobyteus/agent/input_processor/__init__.py

@@ -4,15 +4,9 @@ Components for pre-processing AgentUserMessage objects.
 """
 from .base_user_input_processor import BaseAgentUserInputMessageProcessor
 
-# Import concrete processors to make them easily accessible for instantiation
-from .passthrough_input_processor import PassthroughInputProcessor
-from .metadata_appending_input_processor import MetadataAppendingInputProcessor
-from .content_prefixing_input_processor import ContentPrefixingInputProcessor
+# Concrete processors have been removed. Users can define their own.
 
 
 __all__ = [
     "BaseAgentUserInputMessageProcessor",
-    "PassthroughInputProcessor",
-    "MetadataAppendingInputProcessor",
-    "ContentPrefixingInputProcessor",
 ]

autobyteus/agent/message/context_file_type.py

@@ -17,6 +17,8 @@ class ContextFileType(str, Enum):
     HTML = "html"          # .html, .htm
     PYTHON = "python"      # .py
     JAVASCRIPT = "javascript" # .js
+    AUDIO = "audio"        # .mp3, .wav, .m4a, .flac, .ogg
+    VIDEO = "video"        # .mp4, .mov, .avi, .mkv, .webm
     IMAGE = "image"        # .png, .jpg, .jpeg, .gif, .webp (when image is for contextual analysis, not direct LLM vision input)
     UNKNOWN = "unknown"    # Fallback for unrecognized types
 
@@ -54,6 +56,10 @@ class ContextFileType(str, Enum):
             return cls.PYTHON
         elif extension == ".js":
             return cls.JAVASCRIPT
+        elif extension in [".mp3", ".wav", ".m4a", ".flac", ".ogg"]:
+            return cls.AUDIO
+        elif extension in [".mp4", ".mov", ".avi", ".mkv", ".webm"]:
+            return cls.VIDEO
         elif extension in [".png", ".jpg", ".jpeg", ".gif", ".webp"]:
             return cls.IMAGE 
         else:

autobyteus/agent/message/send_message_to.py

@@ -2,149 +2,118 @@
 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.workflow.context.team_manager import TeamManager
+    from autobyteus.workflow.events.workflow_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 workflow team.
+    This tool requires a TeamManager to be injected at runtime by the
+    workflow framework to enable communication with the parent orchestrator.
     """
-    TOOL_NAME = "SendMessageTo" # Class attribute for the name
+    TOOL_NAME = "SendMessageTo"
+    CATEGORY = ToolCategory.AGENT_COMMUNICATION
+
+    def __init__(self, config: Optional[ToolConfig] = None):
+        """
+        Initializes the SendMessageTo tool. The TeamManager is injected separately
+        after instantiation.
+        """
+        super().__init__(config=config)
+        self._team_manager: Optional['TeamManager'] = None
+        logger.debug("SendMessageTo tool initialized. TeamManager is not yet injected.")
 
-    def __init__(self):
-        super().__init__()
-        logger.debug(f"{self.get_name()} tool initialized.") # Use get_name()
+    def set_team_manager(self, team_manager: 'TeamManager'):
+        """Sets the TeamManager instance after the tool has been created."""
+        self._team_manager = team_manager
+        logger.debug(f"TeamManager was set on SendMessageTo instance post-creation.")
 
     @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 a InterAgentMessageRequestEvent to the parent workflow
+        using the injected team_manager.
         """
-        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}'.")
+        # Local import to break circular dependency at module load time.
+        from autobyteus.workflow.events.workflow_events import InterAgentMessageRequestEvent
 
-        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)
+        if self._team_manager is None:
+            error_msg = "Critical error: SendMessageTo tool is not configured for workflow communication. It can only be used within a managed AgenticWorkflow."
+            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}"
+        # --- 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
             
-            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}")
-            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
-            )
-            
-            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 workflow 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 workflow's event loop via the team manager
+        await self._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_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/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__}>"