autobyteus 1.1.3__tar.gz → 1.1.5__tar.gz

{autobyteus-1.1.3 → autobyteus-1.1.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: autobyteus
-Version: 1.1.3
+Version: 1.1.5
 Summary: Multi-Agent framework
 Home-page: https://github.com/AutoByteus/autobyteus
 Author: Ryan Zheng
@@ -14,26 +14,28 @@ Classifier: Programming Language :: Python :: 3.10
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: aiohttp
+Requires-Dist: anthropic==0.37.1
+Requires-Dist: autobyteus-llm-client==1.1.2
 Requires-Dist: beautifulsoup4>=4.12.2
-Requires-Dist: openai
-Requires-Dist: requests
-Requires-Dist: tiktoken==0.7.0
-Requires-Dist: google-api-python-client
-Requires-Dist: google-generativeai
-Requires-Dist: mistralai
 Requires-Dist: boto3
 Requires-Dist: botocore
-Requires-Dist: anthropic==0.37.1
+Requires-Dist: brui-core==1.0.9
+Requires-Dist: certifi==2025.4.26
+Requires-Dist: google-api-python-client
+Requires-Dist: google-generativeai
 Requires-Dist: Jinja2
-Requires-Dist: ollama
+Requires-Dist: mcp[cli]==1.9.1
 Requires-Dist: mistral_common==1.6.3
+Requires-Dist: mistralai
 Requires-Dist: mistralai==1.5.2
-Requires-Dist: certifi==2025.4.26
 Requires-Dist: numpy==2.2.5
-Requires-Dist: aiohttp
-Requires-Dist: autobyteus-llm-client==1.1.1
-Requires-Dist: brui-core==1.0.8
-Requires-Dist: mcp[cli]==1.9.1
+Requires-Dist: ollama
+Requires-Dist: openai
+Requires-Dist: requests
+Requires-Dist: rich
+Requires-Dist: textual
+Requires-Dist: tiktoken==0.7.0
 Provides-Extra: dev
 Requires-Dist: coverage; extra == "dev"
 Requires-Dist: flake8; extra == "dev"

{autobyteus-1.1.3 → autobyteus-1.1.5}/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-1.1.3 → autobyteus-1.1.5}/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-1.1.3 → autobyteus-1.1.5}/autobyteus/agent/context/__init__.py

@@ -4,10 +4,12 @@ Components related to the agent's runtime context, state, config, and status man
 """
 from .agent_config import AgentConfig
 from .agent_runtime_state import AgentRuntimeState
-from .agent_context import AgentContext 
+from .agent_context import AgentContext
+from .agent_context_registry import AgentContextRegistry
 
 __all__ = [
     "AgentContext",
     "AgentConfig", 
-    "AgentRuntimeState", 
+    "AgentRuntimeState",
+    "AgentContextRegistry",
 ]

{autobyteus-1.1.3 → autobyteus-1.1.5}/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,13 @@ 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 +53,14 @@ 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 +71,41 @@ 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,
+            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-1.1.5/autobyteus/agent/context/agent_context_registry.py

@@ -0,0 +1,73 @@
+# file: autobyteus/autobyteus/agent/context/agent_context_registry.py
+import logging
+from typing import Dict, Optional, TYPE_CHECKING
+import weakref
+
+from autobyteus.utils.singleton import SingletonMeta
+
+if TYPE_CHECKING:
+    from .agent_context import AgentContext
+
+logger = logging.getLogger(__name__)
+
+class AgentContextRegistry(metaclass=SingletonMeta):
+    """
+    A singleton registry that holds weak references to active AgentContext objects,
+    keyed by their agent_id.
+
+    This allows other services to look up an agent's context without creating
+    tight coupling or preventing garbage collection.
+    """
+    def __init__(self):
+        self._contexts: Dict[str, weakref.ReferenceType['AgentContext']] = {}
+        logger.info("AgentContextRegistry (Singleton) initialized.")
+
+    def register_context(self, context: 'AgentContext'):
+        """
+        Registers an agent's context. A weak reference is stored to prevent
+        circular references and allow for proper garbage collection.
+
+        Args:
+            context: The AgentContext instance to register.
+        """
+        agent_id = context.agent_id
+        if agent_id in self._contexts and self._contexts[agent_id]() is not None:
+            logger.warning(f"AgentContext for agent_id '{agent_id}' is already registered. Overwriting.")
+        
+        self._contexts[agent_id] = weakref.ref(context)
+        logger.info(f"Registered AgentContext for agent_id '{agent_id}'. Total registered contexts: {len(self._contexts)}")
+
+    def unregister_context(self, agent_id: str):
+        """
+        Unregisters an agent's context, typically on agent shutdown.
+
+        Args:
+            agent_id: The ID of the agent whose context should be removed.
+        """
+        if agent_id in self._contexts:
+            del self._contexts[agent_id]
+            logger.info(f"Unregistered AgentContext for agent_id '{agent_id}'.")
+        else:
+            logger.warning(f"Attempted to unregister a non-existent AgentContext for agent_id '{agent_id}'.")
+
+    def get_context(self, agent_id: str) -> Optional['AgentContext']:
+        """
+        Retrieves an active agent's context by its ID.
+
+        Args:
+            agent_id: The ID of the agent.
+
+        Returns:
+            The AgentContext instance if found and still alive, otherwise None.
+        """
+        context_ref = self._contexts.get(agent_id)
+        if context_ref:
+            context = context_ref()
+            if context:
+                return context
+            else:
+                # The weak reference is dead, so we can clean it up.
+                logger.debug(f"Cleaning up dead weak reference for agent_id '{agent_id}'.")
+                del self._contexts[agent_id]
+        
+        return None

{autobyteus-1.1.3 → autobyteus-1.1.5}/autobyteus/agent/events/notifiers.py

@@ -112,6 +112,10 @@ class AgentExternalEventNotifier(EventEmitter):
     def notify_agent_tool_invocation_auto_executing(self, auto_exec_data: Dict[str, Any]):
         """Notifies that a tool is being automatically executed."""
         self._emit_event(EventType.AGENT_TOOL_INVOCATION_AUTO_EXECUTING, payload_content=auto_exec_data)
+        
+    def notify_agent_data_system_task_notification_received(self, notification_data: Dict[str, Any]):
+        """Notifies that the agent has received a system-generated task notification."""
+        self._emit_event(EventType.AGENT_DATA_SYSTEM_TASK_NOTIFICATION_RECEIVED, payload_content=notification_data)
 
     def notify_agent_error_output_generation(self, error_source: str, error_message: str, error_details: Optional[str] = None): 
         payload_dict = { 

{autobyteus-1.1.3 → autobyteus-1.1.5}/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-1.1.3 → autobyteus-1.1.5}/autobyteus/agent/handlers/inter_agent_message_event_handler.py

@@ -6,9 +6,11 @@ from autobyteus.agent.handlers.base_event_handler import AgentEventHandler
 from autobyteus.agent.events import InterAgentMessageReceivedEvent, LLMUserMessageReadyEvent 
 from autobyteus.agent.message.inter_agent_message import InterAgentMessage
 from autobyteus.llm.user_message import LLMUserMessage
+from autobyteus.agent.sender_type import TASK_NOTIFIER_SENDER_ID # New import
 
 if TYPE_CHECKING:
     from autobyteus.agent.context import AgentContext 
+    from autobyteus.agent.events.notifiers import AgentExternalEventNotifier
 
 logger = logging.getLogger(__name__)
 
@@ -43,9 +45,13 @@ 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}'"
         )
 
+        # This handler now only deals with messages from other agents, not the system notifier.
+        # The logic for system task notifications has been moved to UserInputMessageEventHandler
+        # by checking the message metadata.
+        
         content_for_llm = (
             f"You have received a message from another agent.\n"
             f"Sender Agent ID: {inter_agent_msg.sender_agent_id}\n"
@@ -54,7 +60,7 @@ class InterAgentMessageReceivedEventHandler(AgentEventHandler):
             f"--- Message Content ---\n"
             f"{inter_agent_msg.content}\n"
             f"--- End of Message Content ---\n"
-            f"Please process this information and respond or act accordingly."
+            f"Please process this information and act accordingly."
         )
         
         context.state.add_message_to_history({
@@ -67,7 +73,6 @@ class InterAgentMessageReceivedEventHandler(AgentEventHandler):
         llm_user_message = LLMUserMessage(content=content_for_llm)
         
         llm_user_message_ready_event = LLMUserMessageReadyEvent(llm_user_message=llm_user_message) 
-        # MODIFIED: Use context.input_event_queues and not context.state.queues
         await context.input_event_queues.enqueue_internal_system_event(llm_user_message_ready_event)
         
         logger.info(

{autobyteus-1.1.3 → autobyteus-1.1.5}/autobyteus/agent/handlers/llm_complete_response_received_event_handler.py

@@ -86,10 +86,8 @@ class LLMCompleteResponseReceivedEventHandler(AgentEventHandler):
                             any_processor_took_action = True
                             logger.info(
                                 f"Agent '{agent_id}': LLMResponseProcessor '{processor_name_for_log}' "
-                                f"handled the response. This LLM response "
-                                f"will not be emitted as a complete response by this handler instance."
+                                f"handled the response."
                             )
-                            break 
                         else:
                             logger.debug(f"Agent '{agent_id}': LLMResponseProcessor '{processor_name_for_log}' did not handle the response.")
 
@@ -102,8 +100,7 @@ class LLMCompleteResponseReceivedEventHandler(AgentEventHandler):
                                 error_message="The model's response contained a malformed tool call that could not be understood.",
                                 error_details=str(e_parse)
                             )
-                        any_processor_took_action = True # Mark as handled to prevent printing raw response
-                        break
+                        # A parsing failure should not prevent other processors from running.
 
                     except Exception as e: # pragma: no cover
                         logger.error(f"Agent '{agent_id}': Error while using LLMResponseProcessor '{processor_name_for_log}': {e}. This processor is skipped.", exc_info=True)
@@ -118,21 +115,24 @@ class LLMCompleteResponseReceivedEventHandler(AgentEventHandler):
                 f"Skipping LLMResponseProcessor attempts."
             )
 
-        if not any_processor_took_action:
-            if is_error_response:
-                logger.info(
-                    f"Agent '{agent_id}' emitting a received error message as a complete response: '{complete_response_text[:100]}...'"
+        # Always notify that the LLM's response is complete, regardless of processor actions.
+        # This serves as a critical signal to the frontend that the stream for this turn has ended.
+        if notifier:
+            if any_processor_took_action:
+                log_message = (
+                    f"Agent '{agent_id}': One or more LLMResponseProcessors handled the response. "
+                    f"Now emitting AGENT_DATA_ASSISTANT_COMPLETE_RESPONSE as a completion signal."
                 )
             else:
-                logger.info(
+                log_message = (
                     f"Agent '{agent_id}': No LLMResponseProcessor handled the response. "
-                    f"Emitting the current LLM response as a complete response for this leg."
+                    f"Emitting the full LLM response as a final answer and completion signal."
                 )
-            
-            if notifier:
-                try:
-                    # The complete_response object now contains both content and reasoning
-                    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.info(log_message)
+
+            try:
+                # The complete_response object now contains both content and reasoning
+                notifier.notify_agent_data_assistant_complete_response(complete_response) 
+                logger.debug(f"Agent '{agent_id}' emitted AGENT_DATA_ASSISTANT_COMPLETE_RESPONSE event successfully.")
+            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)

{autobyteus-1.1.3 → autobyteus-1.1.5}/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-1.1.5/autobyteus/agent/handlers/tool_result_event_handler.py

@@ -0,0 +1,129 @@
+# file: autobyteus/autobyteus/agent/handlers/tool_result_event_handler.py
+import logging
+import json 
+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 
+    from autobyteus.agent.events.notifiers import AgentExternalEventNotifier 
+
+logger = logging.getLogger(__name__)
+
+class ToolResultEventHandler(AgentEventHandler):
+    """
+    Handles ToolResultEvents by formatting the tool's output (or error)
+    as a new LLMUserMessage, emitting AGENT_DATA_TOOL_LOG event for this outcome,
+    and enqueuing an LLMUserMessageReadyEvent for further LLM processing.
+    """
+    def __init__(self):
+        logger.info("ToolResultEventHandler initialized.")
+
+    async def handle(self,
+                     event: ToolResultEvent,
+                     context: 'AgentContext') -> None:
+        if not isinstance(event, ToolResultEvent): 
+            logger.warning(f"ToolResultEventHandler received non-ToolResultEvent: {type(event)}. Skipping.")
+            return
+
+        agent_id = context.agent_id
+        processed_event = event
+
+        # --- 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:
+            notifier = context.phase_manager.notifier
+        
+        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 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(processed_event.result, indent=2)
+            except TypeError: # pragma: no cover
+                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 processed_event.error:
+            content_for_llm = (
+                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: {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": 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(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(processed_event.result)
+
+            content_for_llm = (
+                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: {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": 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 '{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 '{processed_event.tool_name}' (ID: {tool_invocation_id}) result summary.")

{autobyteus-1.1.3 → autobyteus-1.1.5}/autobyteus/agent/handlers/user_input_message_event_handler.py

@@ -11,6 +11,7 @@ from autobyteus.llm.user_message import LLMUserMessage
 
 if TYPE_CHECKING:
     from autobyteus.agent.context import AgentContext 
+    from autobyteus.agent.events.notifiers import AgentExternalEventNotifier
 
 logger = logging.getLogger(__name__)
 
@@ -20,6 +21,7 @@ class UserInputMessageEventHandler(AgentEventHandler):
     AgentUserInputMessageProcessors (provided as instances) to the AgentInputUserMessage,
     then converting the processed message into an LLMUserMessage, and finally
     enqueuing an LLMUserMessageReadyEvent for further processing by the LLM.
+    It also checks for metadata to emit special notifications for system-generated tasks.
     """
 
     def __init__(self):
@@ -33,9 +35,22 @@ class UserInputMessageEventHandler(AgentEventHandler):
             return
 
         original_agent_input_user_msg: AgentInputUserMessage = event.agent_input_user_message 
+        
+        # --- NEW LOGIC: Check metadata for system-generated tasks and notify TUI ---
+        if original_agent_input_user_msg.metadata.get('source') == 'system_task_notifier':
+            if context.phase_manager:
+                notifier: 'AgentExternalEventNotifier' = context.phase_manager.notifier
+                notification_data = {
+                    "sender_id": "system.task_notifier",
+                    "content": original_agent_input_user_msg.content,
+                }
+                notifier.notify_agent_data_system_task_notification_received(notification_data)
+                logger.info(f"Agent '{context.agent_id}' emitted system task notification for TUI.")
+        # --- END NEW LOGIC ---
+        
         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-1.1.5/autobyteus/agent/input_processor/__init__.py

@@ -0,0 +1,12 @@
+# file: autobyteus/autobyteus/agent/input_processor/__init__.py
+"""
+Components for pre-processing AgentUserMessage objects.
+"""
+from .base_user_input_processor import BaseAgentUserInputMessageProcessor
+
+# Concrete processors have been removed. Users can define their own.
+
+
+__all__ = [
+    "BaseAgentUserInputMessageProcessor",
+]

{autobyteus-1.1.3 → autobyteus-1.1.5}/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: