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

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/agent/context/agent_config.py

@@ -37,7 +37,6 @@ class AgentConfig:
                  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,
@@ -58,7 +57,6 @@ class AgentConfig:
                            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.
@@ -76,7 +74,6 @@ class AgentConfig:
         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)
@@ -101,7 +98,6 @@ class AgentConfig:
             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

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/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/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__)
 
@@ -46,6 +48,10 @@ class InterAgentMessageReceivedEventHandler(AgentEventHandler):
             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/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/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,6 +35,19 @@ 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}'") 

autobyteus/agent/message/send_message_to.py

@@ -1,4 +1,4 @@
-# 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
 
@@ -9,33 +9,30 @@ 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.workflow.context.team_manager import TeamManager
-    from autobyteus.workflow.events.workflow_events import InterAgentMessageRequestEvent
+    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 workflow team.
-    This tool requires a TeamManager to be injected at runtime by the
-    workflow framework to enable communication with the parent orchestrator.
+    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"
     CATEGORY = ToolCategory.AGENT_COMMUNICATION
 
     def __init__(self, config: Optional[ToolConfig] = None):
         """
-        Initializes the SendMessageTo tool. The TeamManager is injected separately
-        after instantiation.
+        Initializes the stateless SendMessageTo tool.
         """
         super().__init__(config=config)
-        self._team_manager: Optional['TeamManager'] = None
-        logger.debug("SendMessageTo tool initialized. TeamManager is not yet injected.")
+        # The TeamManager is no longer stored as an instance variable.
+        logger.debug("SendMessageTo tool initialized (stateless).")
 
-    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.")
+    # The set_team_manager method has been removed.
 
     @classmethod
     def get_name(cls) -> str:
@@ -75,14 +72,23 @@ class SendMessageTo(BaseTool):
                        content: str, 
                        message_type: str) -> str:
         """
-        Creates and dispatches a InterAgentMessageRequestEvent to the parent workflow
-        using the injected team_manager.
+        Creates and dispatches an InterAgentMessageRequestEvent to the parent agent team
+        by retrieving the TeamManager from the agent's context.
         """
         # Local import to break circular dependency at module load time.
-        from autobyteus.workflow.events.workflow_events import InterAgentMessageRequestEvent
+        from autobyteus.agent_team.events.agent_team_events import InterAgentMessageRequestEvent
 
-        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."
+        # --- 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}"
+        
+        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}"
 
@@ -103,7 +109,7 @@ class SendMessageTo(BaseTool):
         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
+        # Create the event for the agent team to handle
         event = InterAgentMessageRequestEvent(
             sender_agent_id=sender_agent_id,
             recipient_name=recipient_name,
@@ -111,9 +117,9 @@ class SendMessageTo(BaseTool):
             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)
+        # 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)
 
         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
+        return success_msg

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/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_team/__init__.py

@@ -0,0 +1 @@
+# file: autobyteus/autobyteus/agent_team/__init__.py

autobyteus/agent_team/agent_team.py

@@ -0,0 +1,93 @@
+# file: autobyteus/autobyteus/agent_team/agent_team.py
+import logging
+from typing import Optional
+
+from autobyteus.agent_team.runtime.agent_team_runtime import AgentTeamRuntime
+from autobyteus.agent_team.events.agent_team_events import ProcessUserMessageEvent, ToolApprovalTeamEvent
+from autobyteus.agent.message.agent_input_user_message import AgentInputUserMessage
+from autobyteus.agent_team.phases.agent_team_operational_phase import AgentTeamOperationalPhase
+
+logger = logging.getLogger(__name__)
+
+class AgentTeam:
+    """
+    User-facing facade for interacting with a managed agent team.
+    This class is a lightweight wrapper around an AgentTeamRuntime instance
+    and is typically created by an AgentTeamFactory.
+    """
+    def __init__(self, runtime: AgentTeamRuntime):
+        """
+        Initializes the AgentTeam facade.
+
+        Args:
+            runtime: The pre-configured and ready-to-use runtime for the agent team.
+        """
+        if not isinstance(runtime, AgentTeamRuntime):
+            raise TypeError(f"AgentTeam requires an AgentTeamRuntime instance, got {type(runtime).__name__}")
+        
+        self._runtime = runtime
+        self.team_id: str = self._runtime.context.team_id
+        logger.info(f"AgentTeam facade created for team ID '{self.team_id}'.")
+
+    @property
+    def name(self) -> str:
+        return self._runtime.context.config.name
+
+    @property
+    def role(self) -> Optional[str]:
+        """The role of the team, for when it's used as a sub-team."""
+        return self._runtime.context.config.role
+
+    async def post_message(self, message: AgentInputUserMessage, target_agent_name: Optional[str] = None) -> None:
+        """
+        Submits a message to the agent team, routing it to a specific node (agent or sub-team).
+        If `target_agent_name` is not provided, the message is sent to the team's coordinator.
+        """
+        final_target_name = target_agent_name or self._runtime.context.config.coordinator_node.name
+        logger.info(f"Agent Team '{self.team_id}': post_message called. Target: '{final_target_name}'.")
+
+        if not self._runtime.is_running:
+            self.start()
+        
+        event = ProcessUserMessageEvent(
+            user_message=message,
+            target_agent_name=final_target_name
+        )
+        await self._runtime.submit_event(event)
+
+    async def post_tool_execution_approval(
+        self,
+        agent_name: str,
+        tool_invocation_id: str,
+        is_approved: bool,
+        reason: Optional[str] = None
+    ):
+        """Submits a tool execution approval/denial to a specific agent in the team."""
+        logger.info(f"Agent Team '{self.team_id}': post_tool_execution_approval called for agent '{agent_name}'. Approved: {is_approved}.")
+        if not self._runtime.is_running:
+            logger.warning(f"Agent Team '{self.team_id}' is not running. Cannot post approval.")
+            return
+
+        event = ToolApprovalTeamEvent(
+            agent_name=agent_name,
+            tool_invocation_id=tool_invocation_id,
+            is_approved=is_approved,
+            reason=reason,
+        )
+        await self._runtime.submit_event(event)
+
+    def start(self) -> None:
+        """Starts the agent team's background worker thread."""
+        self._runtime.start()
+
+    async def stop(self, timeout: float = 10.0) -> None:
+        """Stops the agent team and all its agents."""
+        await self._runtime.stop(timeout)
+
+    @property
+    def is_running(self) -> bool:
+        """Checks if the agent team's worker is running."""
+        return self._runtime.is_running
+        
+    def get_current_phase(self) -> AgentTeamOperationalPhase: 
+        return self._runtime.context.state.current_phase