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

autobyteus/agent/system_prompt_processor/tool_manifest_injector_processor.py

@@ -1,12 +1,10 @@
 # file: autobyteus/autobyteus/agent/system_prompt_processor/tool_manifest_injector_processor.py
 import logging
-from typing import Dict, TYPE_CHECKING, List
+from typing import Dict, List, TYPE_CHECKING
 
 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
@@ -14,19 +12,12 @@ if TYPE_CHECKING:
 
 logger = logging.getLogger(__name__)
 
+
 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.
+    Appends an 'Accessible Tools' section to the system prompt.
+    Automatically determines XML or JSON format 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"
-
-    def __init__(self):
-        self._manifest_provider = ToolManifestProvider()
-        logger.debug(f"{self.get_name()} initialized.")
 
     @classmethod
     def get_name(cls) -> str:
@@ -34,63 +25,53 @@ class ToolManifestInjectorProcessor(BaseSystemPromptProcessor):
 
     @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)
-        except Exception as e:
-            logger.error(f"Failed to create PromptTemplate from system prompt for agent '{agent_id}'. Error: {e}", exc_info=True)
-            # Return original prompt on Jinja2 parsing failure
-            return system_prompt
+    def __init__(self):
+        self._manifest_provider = None
 
-        # Check if the 'tools' variable is actually in the template
-        if "tools" not in prompt_template.required_vars:
+    def process(
+        self,
+        system_prompt: str,
+        tool_instances: Dict[str, 'BaseTool'],
+        agent_id: str,
+        context: 'AgentContext'
+    ) -> str:
+        if not tool_instances:
+            logger.info(f"Agent '{agent_id}': No tools configured. Skipping tool injection.")
             return system_prompt
 
+        # Get LLM provider for format selection
         llm_provider = None
         if context.llm_instance and context.llm_instance.model:
             llm_provider = context.llm_instance.model.provider
-        
-        # Retrieve the override flag from the agent's configuration.
-        use_xml_tool_format = context.config.use_xml_tool_format
 
-        # Generate the manifest string for the 'tools' variable.
-        tools_manifest: str
-        if not tool_instances:
-            logger.info(f"{self.get_name()}: The '{{{{tools}}}}' placeholder is present, but no tools are instantiated. Using 'No tools available.'")
-            tools_manifest = "No tools available for this agent."
-        else:
-            tool_definitions: List[ToolDefinition] = [
-                td for name in tool_instances if (td := default_tool_registry.get_tool_definition(name))
-            ]
+        # Get tool definitions
+        tool_definitions: List[ToolDefinition] = [
+            td for name in tool_instances if (td := default_tool_registry.get_tool_definition(name))
+        ]
+
+        if not tool_definitions:
+            logger.warning(f"Agent '{agent_id}': Tools configured but no definitions found in registry.")
+            return system_prompt
 
-            try:
-                # Delegate manifest generation to the provider, passing the override flag.
-                tools_manifest = self._manifest_provider.provide(
-                    tool_definitions=tool_definitions,
-                    provider=llm_provider,
-                    use_xml_tool_format=use_xml_tool_format
-                )
-            except Exception as e:
-                logger.exception(f"An unexpected error occurred during tool manifest generation for agent '{agent_id}': {e}")
-                tools_manifest = "Error: Could not generate tool descriptions."
-        
-        # Check if the prompt *only* contains the 'tools' variable by rendering with an empty string
-        rendered_without_tools = prompt_template.fill({"tools": ""})
-        is_tools_only_prompt = not rendered_without_tools.strip()
+        # Generate manifest
+        try:
+            if self._manifest_provider is None:
+                self._manifest_provider = ToolManifestProvider()
+            tools_manifest = self._manifest_provider.provide(
+                tool_definitions=tool_definitions,
+                provider=llm_provider,
+            )
+        except Exception as e:
+            logger.exception(f"Agent '{agent_id}': Failed to generate tool manifest: {e}")
+            return system_prompt
 
-        if is_tools_only_prompt:
-             logger.info(f"{self.get_name()}: Prompt contains only the tools placeholder. Prepending default instructions.")
-             return self.DEFAULT_PREFIX_FOR_TOOLS_ONLY_PROMPT + tools_manifest
-        else:
-            # For prompts that contain other text, add a newline for better formatting before filling the template.
-            tools_description_with_newline = f"\n{tools_manifest}"
-            final_prompt = prompt_template.fill({"tools": tools_description_with_newline})
-            return final_prompt
+        # Append tools section
+        tools_block = f"\n\n## Accessible Tools\n\n{tools_manifest}"
+        logger.info(f"Agent '{agent_id}': Injected {len(tool_definitions)} tools.")
+        return system_prompt + tools_block

autobyteus/agent/token_budget.py

@@ -0,0 +1,56 @@
+from dataclasses import dataclass
+from typing import Optional
+
+from autobyteus.llm.models import LLMModel
+from autobyteus.llm.utils.llm_config import LLMConfig
+from autobyteus.memory.policies.compaction_policy import CompactionPolicy
+
+
+@dataclass(frozen=True)
+class TokenBudget:
+    max_context_tokens: int
+    max_output_tokens: int
+    safety_margin_tokens: int
+    compaction_ratio: float
+    input_budget: int
+
+
+def resolve_token_budget(
+    model: LLMModel,
+    config: LLMConfig,
+    policy: CompactionPolicy,
+) -> Optional[TokenBudget]:
+    max_context_tokens = model.max_context_tokens or config.token_limit
+    if not max_context_tokens:
+        return None
+
+    max_output_tokens = config.max_tokens or 0
+
+    if config.safety_margin_tokens is not None:
+        safety_margin = config.safety_margin_tokens
+    elif model.default_safety_margin_tokens is not None:
+        safety_margin = model.default_safety_margin_tokens
+    else:
+        safety_margin = policy.safety_margin_tokens
+
+    if config.compaction_ratio is not None:
+        compaction_ratio = config.compaction_ratio
+    elif model.default_compaction_ratio is not None:
+        compaction_ratio = model.default_compaction_ratio
+    else:
+        compaction_ratio = policy.trigger_ratio
+
+    input_budget = max(0, max_context_tokens - max_output_tokens - safety_margin)
+
+    return TokenBudget(
+        max_context_tokens=max_context_tokens,
+        max_output_tokens=max_output_tokens,
+        safety_margin_tokens=safety_margin,
+        compaction_ratio=compaction_ratio,
+        input_budget=input_budget,
+    )
+
+
+def apply_compaction_policy(policy: CompactionPolicy, budget: TokenBudget) -> None:
+    policy.trigger_ratio = budget.compaction_ratio
+    policy.safety_margin_tokens = budget.safety_margin_tokens

autobyteus/agent/tool_execution_result_processor/memory_ingest_tool_result_processor.py

@@ -0,0 +1,29 @@
+import logging
+from typing import TYPE_CHECKING
+
+from autobyteus.agent.tool_execution_result_processor.base_processor import BaseToolExecutionResultProcessor
+
+if TYPE_CHECKING:
+    from autobyteus.agent.context import AgentContext
+    from autobyteus.agent.events import ToolResultEvent
+
+logger = logging.getLogger(__name__)
+
+
+class MemoryIngestToolResultProcessor(BaseToolExecutionResultProcessor):
+    @classmethod
+    def get_order(cls) -> int:
+        return 900
+
+    async def process(self, event: "ToolResultEvent", context: "AgentContext") -> "ToolResultEvent":
+        memory_manager = getattr(context.state, "memory_manager", None)
+        if memory_manager:
+            if event.turn_id:
+                memory_manager.ingest_tool_result(event)
+                logger.debug("MemoryIngestToolResultProcessor stored tool result for turn_id %s", event.turn_id)
+            else:
+                logger.debug(
+                    "MemoryIngestToolResultProcessor skipping tool result without turn_id for tool '%s'",
+                    event.tool_name,
+                )
+        return event

autobyteus/agent/tool_invocation.py

@@ -1,9 +1,6 @@
 # file: autobyteus/autobyteus/agent/tool_invocation.py
-import uuid
-import hashlib
-import json
 import logging
-from typing import Optional, Dict, Any, List, TYPE_CHECKING
+from typing import Dict, Any, List, TYPE_CHECKING, Optional
 from dataclasses import dataclass, field
 
 if TYPE_CHECKING:
@@ -12,48 +9,26 @@ if TYPE_CHECKING:
 logger = logging.getLogger(__name__)
 
 class ToolInvocation:
-    def __init__(self, name: Optional[str] = None, arguments: Optional[Dict[str, Any]] = None, id: Optional[str] = None):
+    def __init__(self, name: str, arguments: Dict[str, Any], id: str, turn_id: str = None):
         """
         Represents a tool invocation request.
 
         Args:
             name: The name of the tool to be invoked.
             arguments: A dictionary of arguments for the tool.
-            id: Optional. A unique identifier for this tool invocation.
-                If None, a deterministic ID will be generated based on the tool name and arguments.
+            id: Required. A unique identifier for this tool invocation.
         """
-        self.name: Optional[str] = name
-        self.arguments: Optional[Dict[str, Any]] = arguments
-        
-        if id is not None:
-            self.id: str = id
-        elif self.name is not None and self.arguments is not None:
-            self.id: str = self._generate_deterministic_id(self.name, self.arguments)
-        else:
-            # Fallback to UUID if name/args are not provided during init, though this is an edge case.
-            self.id: str = f"call_{uuid.uuid4().hex}"
-
-    @staticmethod
-    def _generate_deterministic_id(name: str, arguments: Dict[str, Any]) -> str:
-        """
-        Generates a deterministic ID for the tool invocation based on its content.
-        """
-        # Create a canonical representation of the arguments
-        # sort_keys=True ensures that the order of keys doesn't change the hash
-        # ensure_ascii=False is critical for cross-language compatibility with JS
-        canonical_args = json.dumps(arguments, sort_keys=True, separators=(',', ':'), ensure_ascii=False)
-        
-        # Create a string to hash
-        hash_string = f"{name}:{canonical_args}"
-        
-        # --- ADDED LOGGING ---
-        logger.debug(f"Generating tool invocation ID from hash_string: '{hash_string}'")
-        
-        # Use SHA256 for a robust hash
-        sha256_hash = hashlib.sha256(hash_string.encode('utf-8')).hexdigest()
-        
-        # Prepend a prefix for clarity and use the full hash.
-        return f"call_{sha256_hash}"
+        if not id:
+            raise ValueError("ToolInvocation requires a non-empty id.")
+        if not name:
+            raise ValueError("ToolInvocation requires a non-empty name.")
+        if arguments is None:
+            raise ValueError("ToolInvocation requires arguments.")
+
+        self.name: str = name
+        self.arguments: Dict[str, Any] = arguments
+        self.id: str = id
+        self.turn_id: Optional[str] = turn_id
 
     def is_valid(self) -> bool:
         """
@@ -63,7 +38,8 @@ class ToolInvocation:
         return self.name is not None and self.arguments is not None
 
     def __repr__(self) -> str:
-        return (f"ToolInvocation(id='{self.id}', name='{self.name}', "
+        turn_id_repr = f", turn_id='{self.turn_id}'" if self.turn_id else ""
+        return (f"ToolInvocation(id='{self.id}', name='{self.name}'{turn_id_repr}, "
                 f"arguments={self.arguments})")
 
 

autobyteus/agent/tool_invocation_preprocessor/__init__.py

@@ -0,0 +1,9 @@
+from .base_preprocessor import BaseToolInvocationPreprocessor
+from .processor_definition import ToolInvocationPreprocessorDefinition
+from .processor_registry import default_tool_invocation_preprocessor_registry
+
+__all__ = [
+    "BaseToolInvocationPreprocessor",
+    "ToolInvocationPreprocessorDefinition",
+    "default_tool_invocation_preprocessor_registry",
+]

autobyteus/agent/tool_invocation_preprocessor/base_preprocessor.py

@@ -0,0 +1,45 @@
+import logging
+from abc import ABC, abstractmethod
+from typing import TYPE_CHECKING
+
+from .processor_meta import ToolInvocationPreprocessorMeta
+
+if TYPE_CHECKING:
+    from autobyteus.agent.context import AgentContext
+    from autobyteus.agent.tool_invocation import ToolInvocation
+
+logger = logging.getLogger(__name__)
+
+
+class BaseToolInvocationPreprocessor(ABC, metaclass=ToolInvocationPreprocessorMeta):
+    """
+    Pre-execution processors that can mutate or validate a ToolInvocation
+    before the tool is executed.
+    """
+
+    @classmethod
+    def get_name(cls) -> str:
+        return cls.__name__
+
+    @classmethod
+    def get_order(cls) -> int:
+        """Lower numbers run earlier."""
+        return 500
+
+    @classmethod
+    def is_mandatory(cls) -> bool:
+        return False
+
+    @abstractmethod
+    async def process(self,
+                      invocation: 'ToolInvocation',
+                      context: 'AgentContext') -> 'ToolInvocation':
+        """
+        Process and return the (potentially modified) ToolInvocation.
+        May raise to signal failure; caller should handle and surface as tool error.
+        """
+        raise NotImplementedError
+
+    def __repr__(self) -> str:
+        return f"<{self.__class__.__name__}>"
+

autobyteus/agent/tool_invocation_preprocessor/processor_definition.py

@@ -0,0 +1,15 @@
+from typing import TYPE_CHECKING, Type
+
+if TYPE_CHECKING:
+    from .base_preprocessor import BaseToolInvocationPreprocessor
+
+
+class ToolInvocationPreprocessorDefinition:
+    """
+    Lightweight container binding a name to a preprocessor class.
+    Mirrors the pattern used by other processor registries.
+    """
+    def __init__(self, name: str, processor_class: Type['BaseToolInvocationPreprocessor']):
+        self.name = name
+        self.processor_class: Type['BaseToolInvocationPreprocessor'] = processor_class
+

autobyteus/agent/tool_invocation_preprocessor/processor_meta.py

@@ -0,0 +1,33 @@
+import logging
+from abc import ABCMeta
+
+from .processor_registry import default_tool_invocation_preprocessor_registry
+from .processor_definition import ToolInvocationPreprocessorDefinition
+
+logger = logging.getLogger(__name__)
+
+
+class ToolInvocationPreprocessorMeta(ABCMeta):
+    """
+    Metaclass to auto-register concrete preprocessors.
+    """
+    def __init__(cls, name, bases, dct):
+        super().__init__(name, bases, dct)
+
+        if name == "BaseToolInvocationPreprocessor" or getattr(cls, "__abstractmethods__", None):
+            logger.debug(f"Skipping registration for abstract tool invocation preprocessor class: {name}")
+            return
+
+        try:
+            processor_name = cls.get_name()
+            if not processor_name or not isinstance(processor_name, str):
+                logger.error(f"Tool invocation preprocessor class {name} must return valid string from get_name(); skipping.")
+                return
+            definition = ToolInvocationPreprocessorDefinition(name=processor_name, processor_class=cls)
+            default_tool_invocation_preprocessor_registry.register_preprocessor(definition)
+            logger.info(f"Auto-registered tool invocation preprocessor '{processor_name}' from class {name}.")
+        except AttributeError as e:
+            logger.error(f"Tool invocation preprocessor class {name} missing required methods ({e}); skipping registration.")
+        except Exception as e:
+            logger.error(f"Failed to auto-register tool invocation preprocessor class {name}: {e}", exc_info=True)
+

autobyteus/agent/tool_invocation_preprocessor/processor_registry.py

@@ -0,0 +1,60 @@
+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 ToolInvocationPreprocessorDefinition
+
+if TYPE_CHECKING:
+    from .base_preprocessor import BaseToolInvocationPreprocessor
+
+logger = logging.getLogger(__name__)
+
+
+class ToolInvocationPreprocessorRegistry(metaclass=SingletonMeta):
+    """
+    Registry for ToolInvocationPreprocessor definitions.
+    """
+    def __init__(self):
+        self._definitions: Dict[str, ToolInvocationPreprocessorDefinition] = {}
+        logger.info("ToolInvocationPreprocessorRegistry initialized.")
+
+    def register_preprocessor(self, definition: ToolInvocationPreprocessorDefinition) -> None:
+        if not isinstance(definition, ToolInvocationPreprocessorDefinition):
+            raise TypeError(f"Expected ToolInvocationPreprocessorDefinition, got {type(definition).__name__}")
+        name = definition.name
+        if name in self._definitions:
+            logger.warning(f"Overwriting existing tool invocation preprocessor definition '{name}'.")
+        self._definitions[name] = definition
+        logger.info(f"Tool invocation preprocessor definition '{name}' registered.")
+
+    def get_preprocessor_definition(self, name: str) -> Optional[ToolInvocationPreprocessorDefinition]:
+        return self._definitions.get(name)
+
+    def get_preprocessor(self, name: str) -> Optional['BaseToolInvocationPreprocessor']:
+        definition = self.get_preprocessor_definition(name)
+        if definition:
+            try:
+                return definition.processor_class()
+            except Exception as e:
+                logger.error(f"Failed to instantiate tool invocation preprocessor '{name}': {e}", exc_info=True)
+                return None
+        return None
+
+    def list_preprocessor_names(self) -> List[str]:
+        return list(self._definitions.keys())
+
+    # Backwards-compatible alias used by some services
+    def get_processor(self, name: str) -> Optional['BaseToolInvocationPreprocessor']:
+        return self.get_preprocessor(name)
+
+    def get_ordered_processor_options(self) -> List[ProcessorOption]:
+        definitions = list(self._definitions.values())
+        sorted_defs = 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_defs]
+
+    def get_all_definitions(self) -> Dict[str, ToolInvocationPreprocessorDefinition]:
+        return dict(self._definitions)
+
+
+default_tool_invocation_preprocessor_registry = ToolInvocationPreprocessorRegistry()

autobyteus/agent/utils/wait_for_idle.py

@@ -1,25 +1,23 @@
 # file: autobyteus/autobyteus/agent/utils/wait_for_idle.py
 import asyncio
 import logging
-from typing import Optional
 
 from autobyteus.agent.agent import Agent
 from autobyteus.agent.streaming.agent_event_stream import AgentEventStream
-from autobyteus.agent.streaming.stream_events import StreamEventType
-from autobyteus.agent.phases import AgentOperationalPhase
+from autobyteus.agent.status.status_enum import AgentStatus
 
 logger = logging.getLogger(__name__)
 
 async def _wait_loop(streamer: AgentEventStream, agent_id: str):
-    """Internal helper to listen for the IDLE or ERROR event."""
-    async for event in streamer.all_events():
-        if event.event_type == StreamEventType.AGENT_IDLE:
+    """Internal helper to listen for the IDLE or ERROR status update."""
+    async for status_update in streamer.stream_status_updates():
+        if status_update.new_status == AgentStatus.IDLE:
             logger.info(f"Agent '{agent_id}' has become idle.")
             return
-        if event.event_type == StreamEventType.ERROR_EVENT:
-             error_message = f"Agent '{agent_id}' entered an error state while waiting for idle: {event.data}"
-             logger.error(error_message)
-             raise RuntimeError(error_message)
+        if status_update.new_status == AgentStatus.ERROR:
+            error_message = f"Agent '{agent_id}' entered an error state while waiting for idle: {status_update}"
+            logger.error(error_message)
+            raise RuntimeError(error_message)
 
 
 async def wait_for_agent_to_be_idle(agent: Agent, timeout: float = 30.0):
@@ -41,12 +39,12 @@ async def wait_for_agent_to_be_idle(agent: Agent, timeout: float = 30.0):
     if not isinstance(agent, Agent):
         raise TypeError("The 'agent' argument must be an instance of the Agent class.")
 
-    current_phase = agent.get_current_phase()
-    if current_phase.is_terminal():
-        logger.warning(f"Agent '{agent.agent_id}' is already in a terminal state ({current_phase.value}) and will not become idle.")
+    current_status = agent.get_current_status()
+    if current_status.is_terminal():
+        logger.warning(f"Agent '{agent.agent_id}' is already in a terminal state ({current_status.value}) and will not become idle.")
         return
 
-    if current_phase == AgentOperationalPhase.IDLE:
+    if current_status == AgentStatus.IDLE:
         logger.debug(f"Agent '{agent.agent_id}' is already idle.")
         return
 

autobyteus/agent/workspace/base_workspace.py

@@ -2,9 +2,7 @@
 import logging
 import uuid
 from abc import ABC, abstractmethod
-from typing import Optional, Any, Dict, TYPE_CHECKING
-from autobyteus.utils.parameter_schema import ParameterSchema
-from autobyteus.agent.workspace.workspace_meta import WorkspaceMeta
+from typing import Optional, TYPE_CHECKING
 from autobyteus.agent.workspace.workspace_config import WorkspaceConfig
 
 if TYPE_CHECKING:
@@ -12,13 +10,13 @@ if TYPE_CHECKING:
 
 logger = logging.getLogger(__name__)
 
-class BaseAgentWorkspace(ABC, metaclass=WorkspaceMeta):
+class BaseAgentWorkspace(ABC):
     """
     Abstract base class for an agent's workspace or working environment.
 
     A workspace is a passive data container that describes an agent's operating
-    environment (e.g., a local directory, SSH connection details). It does not
-    implement active operations itself; that is the responsibility of Tools.
+    environment (e.g., a local directory). It does not implement active operations
+    itself; that is the responsibility of Tools.
     """
 
     def __init__(self, config: Optional[WorkspaceConfig] = None):
@@ -26,7 +24,7 @@ class BaseAgentWorkspace(ABC, metaclass=WorkspaceMeta):
         Initializes the BaseAgentWorkspace.
 
         Args:
-            config: Optional configuration for the workspace (e.g., base path, credentials).
+            config: Optional configuration for the workspace (e.g., base path).
         """
         self._config: WorkspaceConfig = config or WorkspaceConfig()
         self.context: Optional['AgentContext'] = None
@@ -68,25 +66,6 @@ class BaseAgentWorkspace(ABC, metaclass=WorkspaceMeta):
         """
         return self.workspace_id
 
-    # --- Methods for self-description ---
-
-    @classmethod
-    @abstractmethod
-    def get_workspace_type_name(cls) -> str:
-        """Returns the unique, machine-readable type name for this workspace (e.g., 'local_workspace')."""
-        pass
-    
-    @classmethod
-    @abstractmethod
-    def get_description(cls) -> str:
-        """Returns a user-friendly description of this workspace type."""
-        pass
-    
-    @classmethod
-    @abstractmethod
-    def get_config_schema(cls) -> ParameterSchema:
-        """Returns the ParameterSchema defining the configuration arguments needed to create an instance of this workspace."""
-        pass
-
     def __repr__(self) -> str:
         return f"<{self.__class__.__name__} workspace_id='{self.workspace_id}' agent_id='{self.agent_id or 'N/A'}>"
+

autobyteus/agent_team/agent_team.py

@@ -5,7 +5,7 @@ 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
+from autobyteus.agent_team.status.agent_team_status import AgentTeamStatus
 
 logger = logging.getLogger(__name__)
 
@@ -89,5 +89,5 @@ class AgentTeam:
         """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
+    def get_current_status(self) -> AgentTeamStatus: 
+        return self._runtime.context.state.current_status