autobyteus 1.2.0__py3-none-any.whl → 1.2.3__py3-none-any.whl

{autobyteus-1.2.0.dist-info → autobyteus-1.2.3.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.9.0)
+Generator: setuptools (80.10.2)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

{autobyteus-1.2.0.dist-info → autobyteus-1.2.3.dist-info}/top_level.txt

@@ -1,2 +1 @@
 autobyteus
-examples

autobyteus/agent/bootstrap_steps/agent_runtime_queue_initialization_step.py

@@ -1,57 +0,0 @@
-# file: autobyteus/autobyteus/agent/bootstrap_steps/agent_runtime_queue_initialization_step.py
-import logging
-from typing import TYPE_CHECKING
-
-from .base_bootstrap_step import BaseBootstrapStep
-from autobyteus.agent.events import AgentErrorEvent, AgentInputEventQueueManager
-# AgentOutputDataManager is no longer initialized here.
-
-if TYPE_CHECKING:
-    from autobyteus.agent.context import AgentContext
-    from autobyteus.agent.phases import AgentPhaseManager
-
-logger = logging.getLogger(__name__)
-
-class AgentRuntimeQueueInitializationStep(BaseBootstrapStep):
-    """
-    Bootstrap step for initializing the agent's runtime INPUT event queues.
-    These queues are created within the AgentWorker's event loop.
-    Output data is now handled by emitting events via AgentExternalEventNotifier.
-    """
-    def __init__(self, input_queue_size: int = 0): # Removed output_queue_size
-        self.input_queue_size = input_queue_size
-        logger.debug(f"AgentRuntimeQueueInitializationStep initialized with input_q_size={input_queue_size}.")
-
-    async def execute(self,
-                      context: 'AgentContext',
-                      phase_manager: 'AgentPhaseManager') -> bool:
-        agent_id = context.agent_id
-        logger.info(f"Agent '{agent_id}': Executing AgentRuntimeQueueInitializationStep (for input queues).")
-
-        try:
-            if context.state.input_event_queues is not None: # Check only input queues
-                logger.warning(f"Agent '{agent_id}': Input runtime queues seem to be already initialized. Overwriting. This might indicate a logic error.")
-
-            input_queues = AgentInputEventQueueManager(queue_size=self.input_queue_size)
-            context.state.input_event_queues = input_queues
-            # context.state.output_data_queues is no longer set here.
-
-            logger.info(f"Agent '{agent_id}': AgentInputEventQueueManager initialized and set in agent state.")
-            if context.state.input_event_queues is None: # pragma: no cover
-                raise RuntimeError("Input event queue manager was not successfully set in agent state during AgentRuntimeQueueInitializationStep.")
-            
-            return True
-        except Exception as e:
-            error_message = f"Agent '{agent_id}': Critical failure during AgentRuntimeQueueInitializationStep (input queues): {e}"
-            logger.error(error_message, exc_info=True)
-            
-            # Attempt to enqueue an error event if input_event_queues was partially created
-            # This check itself might be problematic if input_queues is the thing that failed.
-            # However, if it failed *after* assigning self.input_event_queues, this might work.
-            if context.state.input_event_queues and context.state.input_event_queues.internal_system_event_queue: # pragma: no cover
-                 await context.state.input_event_queues.enqueue_internal_system_event(
-                     AgentErrorEvent(error_message=error_message, exception_details=str(e))
-                 )
-            else: # pragma: no cover
-                 logger.error(f"Agent '{agent_id}': Cannot enqueue AgentErrorEvent as input_event_queues are not available after AgentRuntimeQueueInitializationStep failure.")
-            return False

autobyteus/agent/hooks/__init__.py

@@ -1,16 +0,0 @@
-# file: autobyteus/autobyteus/agent/hooks/__init__.py
-"""
-Components for defining and running lifecycle hooks based on agent phase transitions.
-"""
-from .base_phase_hook import BasePhaseHook
-from .hook_definition import PhaseHookDefinition
-from .hook_meta import PhaseHookMeta
-from .hook_registry import PhaseHookRegistry, default_phase_hook_registry
-
-__all__ = [
-    "BasePhaseHook",
-    "PhaseHookDefinition",
-    "PhaseHookMeta",
-    "PhaseHookRegistry",
-    "default_phase_hook_registry",
-]

autobyteus/agent/hooks/base_phase_hook.py

@@ -1,78 +0,0 @@
-# file: autobyteus/autobyteus/agent/hooks/base_phase_hook.py
-import logging
-from abc import ABC, abstractmethod
-from typing import TYPE_CHECKING
-
-from autobyteus.agent.phases import AgentOperationalPhase
-from .hook_meta import PhaseHookMeta
-
-if TYPE_CHECKING:
-    from autobyteus.agent.context import AgentContext
-
-logger = logging.getLogger(__name__)
-
-class BasePhaseHook(ABC, metaclass=PhaseHookMeta):
-    """
-    Abstract base class for creating hooks that execute on specific agent
-    phase transitions.
-
-    Subclasses must define the `source_phase` and `target_phase` to specify
-    the exact transition they are interested in, and implement the `execute`
-    method for their custom logic.
-    """
-
-    @classmethod
-    def get_name(cls) -> str:
-        """
-        Returns the unique registration name for this hook.
-        Defaults to the class name. Can be overridden by subclasses.
-        """
-        return cls.__name__
-
-    @classmethod
-    def get_order(cls) -> int:
-        """
-        Returns the execution order for this hook if multiple hooks are triggered
-        on the same transition. Lower numbers execute earlier.
-        Defaults to 500 (normal priority).
-        """
-        return 500
-
-    @classmethod
-    def is_mandatory(cls) -> bool:
-        """
-        Returns True if this hook is mandatory for the agent to function correctly.
-        Defaults to False (optional).
-        """
-        return False
-
-    @property
-    @abstractmethod
-    def source_phase(self) -> AgentOperationalPhase:
-        """The source phase for the transition this hook targets."""
-        raise NotImplementedError
-
-    @property
-    @abstractmethod
-    def target_phase(self) -> AgentOperationalPhase:
-        """The target phase for the transition this hook targets."""
-        raise NotImplementedError
-
-    @abstractmethod
-    async def execute(self, context: 'AgentContext') -> None:
-        """
-        The method executed when the specified phase transition occurs.
-
-        Args:
-            context: The agent's context at the time of the transition.
-        """
-        raise NotImplementedError
-
-    def __repr__(self) -> str:
-        # Use try-except in case properties are not yet implemented during introspection
-        try:
-            return (f"<{self.__class__.__name__} "
-                    f"source='{self.source_phase.value}' "
-                    f"target='{self.target_phase.value}'>")
-        except (NotImplementedError, AttributeError):
-            return f"<{self.__class__.__name__} (unconfigured)>"

autobyteus/agent/hooks/hook_definition.py

@@ -1,36 +0,0 @@
-# file: autobyteus/autobyteus/agent/hooks/hook_definition.py
-import logging
-from typing import Type, TYPE_CHECKING
-
-if TYPE_CHECKING:
-    from .base_phase_hook import BasePhaseHook
-
-logger = logging.getLogger(__name__)
-
-class PhaseHookDefinition:
-    """
-    Represents the definition of a phase hook.
-    Contains its registered name and the class itself.
-    """
-    def __init__(self, name: str, hook_class: Type['BasePhaseHook']):
-        """
-        Initializes the PhaseHookDefinition.
-
-        Args:
-            name: The unique registered name of the hook.
-            hook_class: The class of the phase hook.
-
-        Raises:
-            ValueError: If name is empty or hook_class is not a type.
-        """
-        if not name or not isinstance(name, str):
-            raise ValueError("Hook name must be a non-empty string.")
-        if not isinstance(hook_class, type):
-            raise ValueError("hook_class must be a class type.")
-        
-        self.name: str = name
-        self.hook_class: Type['BasePhaseHook'] = hook_class
-        logger.debug(f"PhaseHookDefinition created: name='{name}', class='{hook_class.__name__}'.")
-
-    def __repr__(self) -> str:
-        return f"<PhaseHookDefinition name='{self.name}', class='{self.hook_class.__name__}'>"

autobyteus/agent/hooks/hook_meta.py

@@ -1,37 +0,0 @@
-# file: autobyteus/autobyteus/agent/hooks/hook_meta.py
-import logging
-from abc import ABCMeta
-
-from .hook_registry import default_phase_hook_registry
-from .hook_definition import PhaseHookDefinition
-
-logger = logging.getLogger(__name__)
-
-class PhaseHookMeta(ABCMeta):
-    """
-    Metaclass for BasePhaseHook that automatically registers concrete
-    hook subclasses with the default_phase_hook_registry.
-    Registration uses the name obtained from the class method `get_name()`.
-    """
-    def __init__(cls, name, bases, dct):
-        super().__init__(name, bases, dct)
-
-        if name == 'BasePhaseHook' or getattr(cls, "__abstractmethods__", None):
-            logger.debug(f"Skipping registration for abstract phase hook class: {name}")
-            return
-
-        try:
-            hook_name = cls.get_name()
-
-            if not hook_name or not isinstance(hook_name, str):
-                logger.error(f"Phase hook class {name} must return a valid string from static get_name(). Skipping registration.")
-                return
-            
-            definition = PhaseHookDefinition(name=hook_name, hook_class=cls)
-            default_phase_hook_registry.register_hook(definition)
-            logger.info(f"Auto-registered phase hook: '{hook_name}' from class {name} (no schema).")
-
-        except AttributeError as e:
-            logger.error(f"Phase hook class {name} is missing required static/class method 'get_name' ({e}). Skipping registration.")
-        except Exception as e:
-            logger.error(f"Failed to auto-register phase hook class {name}: {e}", exc_info=True)

autobyteus/agent/hooks/hook_registry.py

@@ -1,106 +0,0 @@
-# file: autobyteus/autobyteus/agent/hooks/hook_registry.py
-import logging
-from typing import TYPE_CHECKING, Dict, List, Optional
-
-from autobyteus.utils.singleton import SingletonMeta
-from autobyteus.agent.processor_option import HookOption
-from .hook_definition import PhaseHookDefinition
-
-if TYPE_CHECKING:
-    from .base_phase_hook import BasePhaseHook
-
-logger = logging.getLogger(__name__)
-
-class PhaseHookRegistry(metaclass=SingletonMeta):
-    """
-    A singleton registry for PhaseHookDefinition objects.
-    Hooks are typically auto-registered via PhaseHookMeta.
-    """
-
-    def __init__(self):
-        """Initializes the PhaseHookRegistry with an empty store."""
-        self._definitions: Dict[str, PhaseHookDefinition] = {}
-        logger.info("PhaseHookRegistry initialized.")
-
-    def register_hook(self, definition: PhaseHookDefinition) -> None:
-        """
-        Registers a phase hook definition.
-        """
-        if not isinstance(definition, PhaseHookDefinition):
-            raise TypeError(f"Expected PhaseHookDefinition instance, got {type(definition).__name__}.")
-
-        hook_name = definition.name
-        if hook_name in self._definitions:
-            logger.warning(f"Overwriting existing phase hook definition for name: '{hook_name}'.")
-        
-        self._definitions[hook_name] = definition
-        logger.info(f"Phase hook definition '{hook_name}' (class: '{definition.hook_class.__name__}') registered successfully.")
-
-    def get_hook_definition(self, name: str) -> Optional[PhaseHookDefinition]:
-        """
-        Retrieves a phase hook definition by its name.
-        """
-        if not isinstance(name, str):
-            logger.warning(f"Attempted to retrieve hook definition with non-string name: {type(name).__name__}.")
-            return None
-        definition = self._definitions.get(name)
-        if not definition:
-            logger.debug(f"Phase hook definition with name '{name}' not found in registry.")
-        return definition
-
-    def get_hook(self, name: str) -> Optional['BasePhaseHook']:
-        """
-        Retrieves an instance of a phase hook by its name.
-        """
-        definition = self.get_hook_definition(name)
-        if definition:
-            try:
-                return definition.hook_class()
-            except Exception as e:
-                logger.error(f"Failed to instantiate phase hook '{name}' from class '{definition.hook_class.__name__}': {e}", exc_info=True)
-                return None
-        return None
-
-    def list_hook_names(self) -> List[str]:
-        """
-        Returns an unordered list of names of all registered phase hook definitions.
-        """
-        return list(self._definitions.keys())
-
-    def get_ordered_hook_options(self) -> List[HookOption]:
-        """
-        Returns a list of HookOption objects, sorted by their execution order.
-        """
-        definitions = list(self._definitions.values())
-        sorted_definitions = sorted(definitions, key=lambda d: d.hook_class.get_order())
-        return [
-            HookOption(
-                name=d.name,
-                is_mandatory=d.hook_class.is_mandatory()
-            ) for d in sorted_definitions
-        ]
-
-    def get_all_definitions(self) -> Dict[str, PhaseHookDefinition]:
-        """
-        Returns a shallow copy of the dictionary containing all registered phase hook definitions.
-        """
-        return dict(self._definitions)
-
-    def clear(self) -> None:
-        """Removes all definitions from the registry."""
-        count = len(self._definitions)
-        self._definitions.clear()
-        logger.info(f"Cleared {count} definitions from the PhaseHookRegistry.")
-        
-    def __len__(self) -> int:
-        """Returns the number of registered hook definitions."""
-        return len(self._definitions)
-
-    def __contains__(self, name: str) -> bool:
-        """Checks if a hook definition is in the registry by name."""
-        if isinstance(name, str):
-            return name in self._definitions
-        return False
-
-# Default instance of the registry
-default_phase_hook_registry = PhaseHookRegistry()

autobyteus/agent/llm_response_processor/provider_aware_tool_usage_processor.py

@@ -1,103 +0,0 @@
-# file: autobyteus/autobyteus/agent/llm_response_processor/provider_aware_tool_usage_processor.py
-import logging
-from typing import TYPE_CHECKING, List
-
-from .base_processor import BaseLLMResponseProcessor
-from autobyteus.agent.events import PendingToolInvocationEvent
-from autobyteus.agent.tool_invocation import ToolInvocation, ToolInvocationTurn
-from autobyteus.tools.usage.parsers import ProviderAwareToolUsageParser
-from autobyteus.tools.usage.parsers.exceptions import ToolUsageParseException
-
-if TYPE_CHECKING:
-    from autobyteus.agent.context import AgentContext
-    from autobyteus.agent.events import LLMCompleteResponseReceivedEvent
-    from autobyteus.llm.utils.response_types import CompleteResponse
-
-logger = logging.getLogger(__name__)
-
-class ProviderAwareToolUsageProcessor(BaseLLMResponseProcessor):
-    """
-    A "master" tool usage processor that uses a high-level parser from the
-    `tools` module to extract tool invocations. It then ensures each invocation
-    has a session-unique ID before enqueuing the necessary agent events.
-    """
-    INVOCATION_COUNTS_KEY = "agent_tool_invocation_counts"
-
-    def __init__(self):
-        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
-        IDs unique within the agent's session, and then enqueues a
-        PendingToolInvocationEvent for each one.
-        Propagates ToolUsageParseException if parsing fails.
-        """
-        try:
-            # Delegate parsing to the high-level parser
-            tool_invocations = self._parser.parse(response, context)
-        except ToolUsageParseException:
-            # Re-raise the exception to be caught by the event handler
-            raise
-
-        if not tool_invocations:
-            return False
-
-        # --- NEW LOGIC FOR UNIQUE ID GENERATION ---
-        
-        # Ensure the counter map exists in the agent's state's custom data
-        if self.INVOCATION_COUNTS_KEY not in context.custom_data:
-            context.custom_data[self.INVOCATION_COUNTS_KEY] = {}
-        
-        invocation_counts = context.custom_data[self.INVOCATION_COUNTS_KEY]
-        
-        processed_invocations: List[ToolInvocation] = []
-
-        for invocation in tool_invocations:
-            base_id = invocation.id
-            
-            # Get the current count for this base ID, default to 0
-            count = invocation_counts.get(base_id, 0)
-            
-            # Create the new session-unique ID
-            unique_id = f"{base_id}_{count}"
-            
-            # Update the invocation's ID in-place
-            invocation.id = unique_id
-            
-            # Increment the counter for the next time this base ID is seen
-            invocation_counts[base_id] = count + 1
-            
-            processed_invocations.append(invocation)
-
-        # --- END NEW LOGIC ---
-        
-        # --- NEW: Initialize the multi-tool turn state ---
-        if len(processed_invocations) > 0:
-            logger.info(f"Agent '{context.agent_id}': Initializing multi-tool call turn with {len(processed_invocations)} invocations.")
-            context.state.active_multi_tool_call_turn = ToolInvocationTurn(invocations=processed_invocations)
-        # --- END NEW ---
-
-        logger.info(f"Agent '{context.agent_id}': Parsed {len(processed_invocations)} tool invocations. Enqueuing events with unique IDs.")
-        for invocation in processed_invocations:
-            logger.info(f"Agent '{context.agent_id}' ({self.get_name()}) identified tool invocation: {invocation.name} with unique ID {invocation.id}. Enqueuing event.")
-            await context.input_event_queues.enqueue_tool_invocation_request(
-                PendingToolInvocationEvent(tool_invocation=invocation)
-            )
-        
-        return True

autobyteus/agent/phases/__init__.py

@@ -1,18 +0,0 @@
-# file: autobyteus/autobyteus/agent/phases/__init__.py
-"""
-This package contains components for defining and describing agent operational phases
-and their transitions.
-"""
-from .phase_enum import AgentOperationalPhase
-from .transition_info import PhaseTransitionInfo
-from .transition_decorator import phase_transition
-from .discover import PhaseTransitionDiscoverer
-from .manager import AgentPhaseManager
-
-__all__ = [
-    "AgentOperationalPhase",
-    "PhaseTransitionInfo",
-    "phase_transition",
-    "PhaseTransitionDiscoverer",
-    "AgentPhaseManager",
-]

autobyteus/agent/phases/discover.py

@@ -1,53 +0,0 @@
-# file: autobyteus/autobyteus/agent/phases/discover.py
-import inspect
-import logging
-from typing import List, Optional
-
-from autobyteus.agent.phases.manager import AgentPhaseManager
-
-from .transition_info import PhaseTransitionInfo
-
-logger = logging.getLogger(__name__)
-
-class PhaseTransitionDiscoverer:
-    """
-    A utility class to discover all valid phase transitions within the system.
-    
-    It works by introspecting the AgentPhaseManager and finding methods
-    that have been decorated with the `@phase_transition` decorator.
-    """
-    _cached_transitions: Optional[List[PhaseTransitionInfo]] = None
-
-    @classmethod
-    def discover(cls) -> List[PhaseTransitionInfo]:
-        """
-        Discovers and returns a list of all possible phase transitions.
-        
-        The result is cached after the first call for performance.
-        
-        Returns:
-            A list of PhaseTransitionInfo objects, each describing a valid transition.
-        """
-        if cls._cached_transitions is not None:
-            return cls._cached_transitions
-
-        logger.debug("Discovering phase transitions from AgentPhaseManager for the first time.")
-        transitions = []
-        for name, method in inspect.getmembers(AgentPhaseManager, predicate=inspect.isfunction):
-            if hasattr(method, '_transition_info'):
-                info = getattr(method, '_transition_info')
-                if isinstance(info, PhaseTransitionInfo):
-                    transitions.append(info)
-        
-        # Sort for deterministic output
-        transitions.sort(key=lambda t: (t.target_phase.value, t.triggering_method))
-        
-        cls._cached_transitions = transitions
-        logger.info(f"Discovered and cached {len(transitions)} phase transitions.")
-        return transitions
-
-    @classmethod
-    def clear_cache(cls) -> None:
-        """Clears the cached list of transitions."""
-        cls._cached_transitions = None
-        logger.info("Cleared cached phase transitions.")