autobyteus 1.1.7__py3-none-any.whl → 1.1.9__py3-none-any.whl

autobyteus/agent/llm_response_processor/processor_registry.py

@@ -3,6 +3,7 @@ import logging
 from typing import TYPE_CHECKING, Dict, List, Optional, Type
 
 from autobyteus.utils.singleton import SingletonMeta
+from autobyteus.agent.processor_option import ProcessorOption
 from .processor_definition import LLMResponseProcessorDefinition
 if TYPE_CHECKING:
     from .base_processor import BaseLLMResponseProcessor
@@ -23,14 +24,6 @@ class LLMResponseProcessorRegistry(metaclass=SingletonMeta):
     def register_processor(self, definition: LLMResponseProcessorDefinition) -> None:
         """
         Registers an LLM response processor definition.
-        If a definition with the same name already exists, it will be overwritten,
-        and a warning will be logged.
-
-        Args:
-            definition: The LLMResponseProcessorDefinition object to register.
-
-        Raises:
-            TypeError: If the definition is not an instance of LLMResponseProcessorDefinition.
         """
         if not isinstance(definition, LLMResponseProcessorDefinition):
             raise TypeError(f"Expected LLMResponseProcessorDefinition instance, got {type(definition).__name__}.")
@@ -45,12 +38,6 @@ class LLMResponseProcessorRegistry(metaclass=SingletonMeta):
     def get_processor_definition(self, name: str) -> Optional[LLMResponseProcessorDefinition]:
         """
         Retrieves an LLM response processor definition by its name.
-
-        Args:
-            name: The name of the LLM response processor definition to retrieve.
-
-        Returns:
-            The LLMResponseProcessorDefinition object if found, otherwise None.
         """
         if not isinstance(name, str):
             logger.warning(f"Attempted to retrieve LLM response processor definition with non-string name: {type(name).__name__}.")
@@ -63,12 +50,6 @@ class LLMResponseProcessorRegistry(metaclass=SingletonMeta):
     def get_processor(self, name: str) -> Optional['BaseLLMResponseProcessor']:
         """
         Retrieves an instance of an LLM response processor by its name.
-
-        Args:
-            name: The name of the LLM response processor to retrieve.
-
-        Returns:
-            An instance of the BaseLLMResponseProcessor if found and instantiable, otherwise None.
         """
         definition = self.get_processor_definition(name)
         if definition:
@@ -81,13 +62,23 @@ class LLMResponseProcessorRegistry(metaclass=SingletonMeta):
 
     def list_processor_names(self) -> List[str]:
         """
-        Returns a list of names of all registered LLM response processor definitions.
-
-        Returns:
-            A list of strings, where each string is a registered processor name.
+        Returns an unordered list of names of all registered LLM response processor definitions.
         """
         return list(self._definitions.keys())
 
+    def get_ordered_processor_options(self) -> List[ProcessorOption]:
+        """
+        Returns a list of ProcessorOption objects, sorted by their execution order.
+        """
+        definitions = list(self._definitions.values())
+        sorted_definitions = sorted(definitions, key=lambda d: d.processor_class.get_order())
+        return [
+            ProcessorOption(
+                name=d.name,
+                is_mandatory=d.processor_class.is_mandatory()
+            ) for d in sorted_definitions
+        ]
+
     def get_all_definitions(self) -> Dict[str, LLMResponseProcessorDefinition]:
         """
         Returns a shallow copy of the dictionary containing all registered LLM response processor definitions.

autobyteus/agent/llm_response_processor/provider_aware_tool_usage_processor.py

@@ -27,6 +27,20 @@ class ProviderAwareToolUsageProcessor(BaseLLMResponseProcessor):
         self._parser = ProviderAwareToolUsageParser()
         logger.debug("ProviderAwareToolUsageProcessor initialized.")
 
+    @classmethod
+    def get_name(cls) -> str:
+        return "ProviderAwareToolUsageProcessor"
+
+    @classmethod
+    def get_order(cls) -> int:
+        """Runs with the highest priority to parse for tool calls before any other processing."""
+        return 100
+
+    @classmethod
+    def is_mandatory(cls) -> bool:
+        """This processor is essential for any agent that uses tools."""
+        return True
+
     async def process_response(self, response: 'CompleteResponse', context: 'AgentContext', triggering_event: 'LLMCompleteResponseReceivedEvent') -> bool:
         """
         Uses a ProviderAwareToolUsageParser to get tool invocations, makes their

autobyteus/agent/message/agent_input_user_message.py

@@ -4,6 +4,7 @@ from typing import Optional, List, Dict, Any
 from dataclasses import dataclass, field
 
 from .context_file import ContextFile # Import the new ContextFile dataclass
+from autobyteus.agent.sender_type import SenderType
 
 logger = logging.getLogger(__name__)
 
@@ -15,11 +16,14 @@ class AgentInputUserMessage:
     allowing users to provide various documents and media as context via a single list.
     """
     content: str
+    sender_type: SenderType = SenderType.USER
     context_files: Optional[List[ContextFile]] = field(default=None)
     metadata: Dict[str, Any] = field(default_factory=dict)
 
     def __post_init__(self):
         # Basic type validation that dataclasses don't do automatically for mutable defaults or complex types
+        if not isinstance(self.sender_type, SenderType):
+            raise TypeError(f"AgentInputUserMessage 'sender_type' must be a SenderType enum. Got {type(self.sender_type)}")
         if self.context_files is not None and not (isinstance(self.context_files, list) and all(isinstance(cf, ContextFile) for cf in self.context_files)):
             raise TypeError("AgentInputUserMessage 'context_files' must be a list of ContextFile objects if provided.")
         if not isinstance(self.metadata, dict): # Should be caught by default_factory, but good practice
@@ -30,7 +34,7 @@ class AgentInputUserMessage:
         if logger.isEnabledFor(logging.DEBUG):
             num_context_files = len(self.context_files) if self.context_files else 0
             logger.debug(
-                f"AgentInputUserMessage initialized. Content: '{self.content[:50]}...', "
+                f"AgentInputUserMessage initialized. SenderType: {self.sender_type.value}, Content: '{self.content[:50]}...', "
                 f"Num ContextFiles: {num_context_files}, "
                 f"Metadata keys: {list(self.metadata.keys())}"
             )
@@ -44,6 +48,7 @@ class AgentInputUserMessage:
 
         return {
             "content": self.content,
+            "sender_type": self.sender_type.value,
             "context_files": context_files_dict_list,
             "metadata": self.metadata,
         }
@@ -55,6 +60,13 @@ class AgentInputUserMessage:
         if not isinstance(content, str): # Ensure content is string
             raise ValueError("AgentInputUserMessage 'content' in dictionary must be a string.")
 
+        sender_type_val = data.get("sender_type", "user")
+        try:
+            sender_type = SenderType(sender_type_val)
+        except ValueError:
+            logger.warning(f"Invalid sender_type '{sender_type_val}' in AgentInputUserMessage data. Defaulting to USER.")
+            sender_type = SenderType.USER
+
         context_files_data = data.get("context_files")
         context_files_list: Optional[List[ContextFile]] = None
         if context_files_data is not None:
@@ -68,6 +80,7 @@ class AgentInputUserMessage:
 
         return cls(
             content=content,
+            sender_type=sender_type,
             context_files=context_files_list,
             metadata=metadata
         )
@@ -82,5 +95,5 @@ class AgentInputUserMessage:
             
         meta_repr = f", metadata_keys={list(self.metadata.keys())}" if self.metadata else ""
         
-        return (f"AgentInputUserMessage(content='{content_preview}'"
+        return (f"AgentInputUserMessage(sender_type='{self.sender_type.value}', content='{content_preview}'"
                 f"{context_repr}{meta_repr})")

autobyteus/agent/message/send_message_to.py

@@ -4,7 +4,7 @@ from typing import TYPE_CHECKING, Any, Optional
 
 from autobyteus.tools.base_tool import BaseTool
 from autobyteus.tools.tool_category import ToolCategory
-from autobyteus.tools.parameter_schema import ParameterSchema, ParameterDefinition, ParameterType
+from autobyteus.utils.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:

autobyteus/agent/processor_option.py

@@ -0,0 +1,17 @@
+# file: autobyteus/autobyteus/agent/processor_option.py
+"""
+Defines common data transfer objects for agent component options.
+"""
+from dataclasses import dataclass
+
+@dataclass(frozen=True)
+class ProcessorOption:
+    """A data class representing a processor option for configuration."""
+    name: str
+    is_mandatory: bool
+
+@dataclass(frozen=True)
+class HookOption:
+    """A data class representing a hook option for configuration."""
+    name: str
+    is_mandatory: bool

autobyteus/agent/sender_type.py

@@ -9,6 +9,7 @@ class SenderType(str, Enum):
     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.
+    TOOL = "tool"        # A message generated as the result of a tool execution.
 
 
 # --- System Sender Identification ---

autobyteus/agent/system_prompt_processor/base_processor.py

@@ -24,6 +24,22 @@ class BaseSystemPromptProcessor(ABC, metaclass=SystemPromptProcessorMeta):
         """
         return cls.__name__
 
+    @classmethod
+    def get_order(cls) -> int:
+        """
+        Returns the execution order for this processor. Lower numbers execute earlier.
+        Defaults to 500 (normal priority).
+        """
+        return 500
+
+    @classmethod
+    def is_mandatory(cls) -> bool:
+        """
+        Returns True if this processor is mandatory for the agent to function correctly.
+        Defaults to False (optional).
+        """
+        return False
+
     @abstractmethod
     def process(self,
                 system_prompt: str,
@@ -45,4 +61,4 @@ class BaseSystemPromptProcessor(ABC, metaclass=SystemPromptProcessorMeta):
         raise NotImplementedError("Subclasses must implement the 'process' method.")
 
     def __repr__(self) -> str:
-        return f"<{self.__class__.__name__}>"
+        return f"&lt;{self.__class__.__name__}&gt;"

autobyteus/agent/system_prompt_processor/processor_registry.py

@@ -3,6 +3,7 @@ import logging
 from typing import TYPE_CHECKING, Dict, List, Optional, Type
 
 from autobyteus.utils.singleton import SingletonMeta
+from autobyteus.agent.processor_option import ProcessorOption
 from .processor_definition import SystemPromptProcessorDefinition # Relative import
 
 if TYPE_CHECKING:
@@ -24,14 +25,6 @@ class SystemPromptProcessorRegistry(metaclass=SingletonMeta):
     def register_processor(self, definition: SystemPromptProcessorDefinition) -> None:
         """
         Registers a system prompt processor definition.
-        If a definition with the same name already exists, it will be overwritten,
-        and a warning will be logged.
-
-        Args:
-            definition: The SystemPromptProcessorDefinition object to register.
-
-        Raises:
-            TypeError: If the definition is not an instance of SystemPromptProcessorDefinition.
         """
         if not isinstance(definition, SystemPromptProcessorDefinition):
             raise TypeError(f"Expected SystemPromptProcessorDefinition instance, got {type(definition).__name__}.")
@@ -46,12 +39,6 @@ class SystemPromptProcessorRegistry(metaclass=SingletonMeta):
     def get_processor_definition(self, name: str) -> Optional[SystemPromptProcessorDefinition]:
         """
         Retrieves a system prompt processor definition by its name.
-
-        Args:
-            name: The name of the system prompt processor definition to retrieve.
-
-        Returns:
-            The SystemPromptProcessorDefinition object if found, otherwise None.
         """
         if not isinstance(name, str):
             logger.warning(f"Attempted to retrieve system prompt processor definition with non-string name: {type(name).__name__}.")
@@ -64,12 +51,6 @@ class SystemPromptProcessorRegistry(metaclass=SingletonMeta):
     def get_processor(self, name: str) -> Optional['BaseSystemPromptProcessor']:
         """
         Retrieves an instance of a system prompt processor by its name.
-
-        Args:
-            name: The name of the system prompt processor to retrieve.
-
-        Returns:
-            An instance of the BaseSystemPromptProcessor if found and instantiable, otherwise None.
         """
         definition = self.get_processor_definition(name)
         if definition:
@@ -83,19 +64,26 @@ class SystemPromptProcessorRegistry(metaclass=SingletonMeta):
 
     def list_processor_names(self) -> List[str]:
         """
-        Returns a list of names of all registered system prompt processor definitions.
-
-        Returns:
-            A list of strings, where each string is a registered processor name.
+        Returns an unordered list of names of all registered system prompt processor definitions.
         """
         return list(self._definitions.keys())
 
+    def get_ordered_processor_options(self) -> List[ProcessorOption]:
+        """
+        Returns a list of ProcessorOption objects, sorted by their execution order.
+        """
+        definitions = list(self._definitions.values())
+        sorted_definitions = sorted(definitions, key=lambda d: d.processor_class.get_order())
+        return [
+            ProcessorOption(
+                name=d.name,
+                is_mandatory=d.processor_class.is_mandatory()
+            ) for d in sorted_definitions
+        ]
+
     def get_all_definitions(self) -> Dict[str, SystemPromptProcessorDefinition]:
         """
         Returns a shallow copy of the dictionary containing all registered system prompt processor definitions.
-
-        Returns:
-            A dictionary where keys are processor names and values are SystemPromptProcessorDefinition objects.
         """
         return dict(self._definitions)
 

autobyteus/agent/system_prompt_processor/tool_manifest_injector_processor.py

@@ -32,6 +32,16 @@ class ToolManifestInjectorProcessor(BaseSystemPromptProcessor):
     def get_name(cls) -> str:
         return "ToolManifestInjector"
 
+    @classmethod
+    def get_order(cls) -> int:
+        """Explicitly set to default, as it's often the only system prompt processor."""
+        return 500
+
+    @classmethod
+    def is_mandatory(cls) -> bool:
+        """This processor is essential for the LLM to know which tools are available."""
+        return True
+
     def process(self, system_prompt: str, tool_instances: Dict[str, 'BaseTool'], agent_id: str, context: 'AgentContext') -> str:
         try:
             prompt_template = PromptTemplate(template=system_prompt)

autobyteus/agent/tool_execution_result_processor/base_processor.py

@@ -26,6 +26,22 @@ class BaseToolExecutionResultProcessor(ABC, metaclass=ToolExecutionResultProcess
         """
         return cls.__name__
 
+    @classmethod
+    def get_order(cls) -> int:
+        """
+        Returns the execution order for this processor. Lower numbers execute earlier.
+        Defaults to 500 (normal priority).
+        """
+        return 500
+
+    @classmethod
+    def is_mandatory(cls) -> bool:
+        """
+        Returns True if this processor is mandatory for the agent to function correctly.
+        Defaults to False (optional).
+        """
+        return False
+
     @abstractmethod
     async def process(self,
                       event: 'ToolResultEvent',
@@ -43,4 +59,4 @@ class BaseToolExecutionResultProcessor(ABC, metaclass=ToolExecutionResultProcess
         raise NotImplementedError("Subclasses must implement the 'process' method.")
 
     def __repr__(self) -> str:
-        return f"<{self.__class__.__name__}>"
+        return f"&lt;{self.__class__.__name__}&gt;"

autobyteus/agent/tool_execution_result_processor/processor_registry.py

@@ -3,6 +3,7 @@ import logging
 from typing import TYPE_CHECKING, Dict, List, Optional
 
 from autobyteus.utils.singleton import SingletonMeta
+from autobyteus.agent.processor_option import ProcessorOption
 from .processor_definition import ToolExecutionResultProcessorDefinition
 
 if TYPE_CHECKING:
@@ -56,10 +57,23 @@ class ToolExecutionResultProcessorRegistry(metaclass=SingletonMeta):
 
     def list_processor_names(self) -> List[str]:
         """
-        Returns a list of names of all registered processor definitions.
+        Returns an unordered list of names of all registered processor definitions.
         """
         return list(self._definitions.keys())
 
+    def get_ordered_processor_options(self) -> List[ProcessorOption]:
+        """
+        Returns a list of ProcessorOption objects, sorted by their execution order.
+        """
+        definitions = list(self._definitions.values())
+        sorted_definitions = sorted(definitions, key=lambda d: d.processor_class.get_order())
+        return [
+            ProcessorOption(
+                name=d.name,
+                is_mandatory=d.processor_class.is_mandatory()
+            ) for d in sorted_definitions
+        ]
+
     def get_all_definitions(self) -> Dict[str, ToolExecutionResultProcessorDefinition]:
         """
         Returns a dictionary of all registered processor definitions.

autobyteus/agent/workspace/base_workspace.py

@@ -3,7 +3,7 @@ import logging
 import uuid
 from abc import ABC, abstractmethod
 from typing import Optional, Any, Dict, TYPE_CHECKING
-from autobyteus.tools.parameter_schema import ParameterSchema
+from autobyteus.utils.parameter_schema import ParameterSchema
 from autobyteus.agent.workspace.workspace_meta import WorkspaceMeta
 from autobyteus.agent.workspace.workspace_config import WorkspaceConfig
 

autobyteus/agent/workspace/workspace_definition.py

@@ -4,7 +4,7 @@ for a specific type of agent workspace.
 """
 import logging
 from typing import Type, Optional, TYPE_CHECKING
-from autobyteus.tools.parameter_schema import ParameterSchema
+from autobyteus.utils.parameter_schema import ParameterSchema
 
 if TYPE_CHECKING:
     from autobyteus.agent.workspace.base_workspace import BaseAgentWorkspace

autobyteus/agent_team/bootstrap_steps/team_context_initialization_step.py

@@ -30,7 +30,7 @@ class TeamContextInitializationStep(BaseAgentTeamBootstrapStep):
                 if notifier:
                     # The notifier, a long-lived component, subscribes to events
                     # from the task_board, another long-lived component.
-                    notifier.subscribe_from(sender=task_board, event=EventType.TASK_BOARD_PLAN_PUBLISHED, listener=notifier.handle_and_publish_task_board_event)
+                    notifier.subscribe_from(sender=task_board, event=EventType.TASK_BOARD_TASKS_ADDED, listener=notifier.handle_and_publish_task_board_event)
                     notifier.subscribe_from(sender=task_board, event=EventType.TASK_BOARD_STATUS_UPDATED, listener=notifier.handle_and_publish_task_board_event)
                     logger.info(f"Team '{team_id}': Successfully bridged TaskBoard events to the team notifier.")
                 else:

autobyteus/agent_team/streaming/agent_team_stream_event_payloads.py

@@ -3,7 +3,7 @@ from typing import Optional, Any
 from pydantic import BaseModel, Field
 from autobyteus.agent_team.phases.agent_team_operational_phase import AgentTeamOperationalPhase
 from autobyteus.agent.streaming.stream_events import StreamEvent as AgentStreamEvent
-from autobyteus.task_management.events import TaskPlanPublishedEvent, TaskStatusUpdatedEvent
+from autobyteus.task_management.events import TasksAddedEvent, TaskStatusUpdatedEvent
 # Need to use a forward reference string to avoid circular import at runtime
 from typing import TYPE_CHECKING, Union
 if TYPE_CHECKING:
@@ -29,4 +29,4 @@ class SubTeamEventRebroadcastPayload(BaseModel):
     sub_team_event: "AgentTeamStreamEvent" = Field(..., description="The original, unmodified event from the sub-team's stream")
 
 # --- Payload for events originating from the "TASK_BOARD" source ---
-TaskBoardEventPayload = Union[TaskPlanPublishedEvent, TaskStatusUpdatedEvent]
+TaskBoardEventPayload = Union[TasksAddedEvent, TaskStatusUpdatedEvent]

autobyteus/agent_team/task_notification/__init__.py

@@ -4,8 +4,12 @@ This package contains components for automatically notifying agents of runnable
 """
 from .system_event_driven_agent_task_notifier import SystemEventDrivenAgentTaskNotifier
 from .task_notification_mode import TaskNotificationMode
+from .activation_policy import ActivationPolicy
+from .task_activator import TaskActivator
 
 __all__ = [
     "SystemEventDrivenAgentTaskNotifier",
     "TaskNotificationMode",
+    "ActivationPolicy",
+    "TaskActivator",
 ]

autobyteus/agent_team/task_notification/activation_policy.py

@@ -0,0 +1,70 @@
+# file: autobyteus/autobyteus/agent_team/task_notification/activation_policy.py
+"""
+Defines the policy for deciding which agents should be activated based on task runnability.
+"""
+import logging
+from typing import List, Set
+
+from autobyteus.task_management.task import Task
+
+logger = logging.getLogger(__name__)
+
+class ActivationPolicy:
+    """
+    Encapsulates the "Single Wave" notification logic for an agent team.
+
+    This class maintains a stateful set of agents that have already been
+    activated. It decides which new agents should receive a "start work"
+    notification based on a list of currently runnable tasks.
+    """
+    def __init__(self, team_id: str):
+        """
+        Initializes the ActivationPolicy.
+
+        Args:
+            team_id: The ID of the team this policy belongs to, for logging.
+        """
+        self._team_id = team_id
+        self._activated_agents: Set[str] = set()
+        logger.debug(f"ActivationPolicy initialized for team '{self._team_id}'.")
+
+    def reset(self):
+        """
+        Resets the activation state. This should be called when a new batch of
+        tasks is published to the task board, signifying a new plan or a
+        significant change in scope.
+        """
+        logger.info(f"Team '{self._team_id}': ActivationPolicy state has been reset. All agents are now considered inactive.")
+        self._activated_agents.clear()
+
+    def determine_activations(self, runnable_tasks: List[Task]) -> List[str]:
+        """
+        Determines which agents should be activated based on a list of runnable tasks.
+
+        An agent is selected for activation if they have one or more runnable tasks
+        and have not already been activated in the current work cycle.
+
+        This method is stateful: it updates its internal set of activated agents
+        with the new agents it returns.
+
+        Args:
+            runnable_tasks: A list of tasks that are currently runnable.
+
+        Returns:
+            A list of unique agent names that should be activated.
+        """
+        if not runnable_tasks:
+            return []
+
+        agents_with_runnable_tasks = {task.assignee_name for task in runnable_tasks}
+        
+        # Determine which of these agents have not yet been activated.
+        new_agents_to_activate = list(agents_with_runnable_tasks - self._activated_agents)
+
+        if new_agents_to_activate:
+            # Update the state to remember that these agents have now been activated.
+            self._activated_agents.update(new_agents_to_activate)
+            logger.info(f"Team '{self._team_id}': Policy determined {len(new_agents_to_activate)} new agent(s) to activate: {new_agents_to_activate}. "
+                        f"Total activated agents is now {len(self._activated_agents)}.")
+        
+        return new_agents_to_activate