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

autobyteus/agent/phases/manager.py

@@ -1,265 +0,0 @@
-# file: autobyteus/autobyteus/agent/phases/manager.py
-import asyncio
-import logging
-from typing import TYPE_CHECKING, Optional, Dict, Any
-
-from .phase_enum import AgentOperationalPhase
-from .transition_decorator import phase_transition
-
-if TYPE_CHECKING:
-    from autobyteus.agent.context import AgentContext
-    from autobyteus.agent.tool_invocation import ToolInvocation
-    from autobyteus.agent.events.notifiers import AgentExternalEventNotifier
-
-
-logger = logging.getLogger(__name__)
-
-class AgentPhaseManager:
-    """
-    Manages the operational phase of an agent, uses an AgentExternalEventNotifier
-    to signal phase changes externally, and executes phase transition hooks.
-    """
-    def __init__(self, context: 'AgentContext', notifier: 'AgentExternalEventNotifier'):
-        self.context: 'AgentContext' = context
-        self.notifier: 'AgentExternalEventNotifier' = notifier
-
-        self.context.current_phase = AgentOperationalPhase.UNINITIALIZED
-        
-        logger.debug(f"AgentPhaseManager initialized for agent_id '{self.context.agent_id}'. "
-                     f"Initial phase: {self.context.current_phase.value}. Uses provided notifier.")
-
-    async def _execute_hooks(self, old_phase: AgentOperationalPhase, new_phase: AgentOperationalPhase):
-        """Asynchronously executes hooks that match the given phase transition."""
-        hooks_to_run = [
-            hook for hook in self.context.config.phase_hooks
-            if hook.source_phase == old_phase and hook.target_phase == new_phase
-        ]
-
-        if not hooks_to_run:
-            return
-
-        hook_names = [hook.__class__.__name__ for hook in hooks_to_run]
-        logger.info(f"Agent '{self.context.agent_id}': Executing {len(hooks_to_run)} hooks for transition "
-                    f"'{old_phase.value}' -> '{new_phase.value}': {hook_names}")
-        
-        for hook in hooks_to_run:
-            try:
-                await hook.execute(self.context)
-                logger.debug(f"Agent '{self.context.agent_id}': Hook '{hook.__class__.__name__}' executed successfully.")
-            except Exception as e:
-                logger.error(f"Agent '{self.context.agent_id}': Error executing phase transition hook "
-                             f"'{hook.__class__.__name__}' for '{old_phase.value}' -> '{new_phase.value}': {e}",
-                             exc_info=True)
-                # We log the error but do not halt the agent's phase transition.
-
-    async def _transition_phase(self, new_phase: AgentOperationalPhase,
-                                notify_method_name: str,
-                                additional_data: Optional[Dict[str, Any]] = None):
-        """
-        Private async helper to change the agent's phase, execute hooks, and then
-        call the appropriate notifier method. Hooks are now awaited.
-        """
-        if not isinstance(new_phase, AgentOperationalPhase):
-            logger.error(f"AgentPhaseManager for '{self.context.agent_id}' received invalid type for new_phase: {type(new_phase)}. Must be AgentOperationalPhase.")
-            return
-
-        old_phase = self.context.current_phase
-        
-        if old_phase == new_phase:
-            logger.debug(f"AgentPhaseManager for '{self.context.agent_id}': already in phase {new_phase.value}. No transition.")
-            return
-
-        logger.info(f"Agent '{self.context.agent_id}' phase transitioning from {old_phase.value} to {new_phase.value}.")
-        self.context.current_phase = new_phase
-
-        # Execute and wait for hooks to complete *before* notifying externally.
-        await self._execute_hooks(old_phase, new_phase)
-
-        notifier_method = getattr(self.notifier, notify_method_name, None)
-        if notifier_method and callable(notifier_method):
-            notify_args = {"old_phase": old_phase}
-            if additional_data:
-                notify_args.update(additional_data)
-            
-            notifier_method(**notify_args)
-        else: 
-            logger.error(f"AgentPhaseManager for '{self.context.agent_id}': Notifier method '{notify_method_name}' not found or not callable on {type(self.notifier).__name__}.")
-
-    @phase_transition(
-        source_phases=[AgentOperationalPhase.SHUTDOWN_COMPLETE, AgentOperationalPhase.ERROR],
-        target_phase=AgentOperationalPhase.UNINITIALIZED,
-        description="Triggered when the agent runtime is started or restarted after being in a terminal state."
-    )
-    async def notify_runtime_starting_and_uninitialized(self) -> None:
-        if self.context.current_phase == AgentOperationalPhase.UNINITIALIZED:
-            await self._transition_phase(AgentOperationalPhase.UNINITIALIZED, "notify_phase_uninitialized_entered")
-        elif self.context.current_phase.is_terminal():
-             await self._transition_phase(AgentOperationalPhase.UNINITIALIZED, "notify_phase_uninitialized_entered")
-        else:
-             logger.warning(f"Agent '{self.context.agent_id}' notify_runtime_starting_and_uninitialized called in unexpected phase: {self.context.current_phase.value}")
-
-    @phase_transition(
-        source_phases=[AgentOperationalPhase.UNINITIALIZED],
-        target_phase=AgentOperationalPhase.BOOTSTRAPPING,
-        description="Occurs when the agent's internal bootstrapping process begins."
-    )
-    async def notify_bootstrapping_started(self) -> None:
-        await self._transition_phase(AgentOperationalPhase.BOOTSTRAPPING, "notify_phase_bootstrapping_started")
-
-    @phase_transition(
-        source_phases=[AgentOperationalPhase.BOOTSTRAPPING],
-        target_phase=AgentOperationalPhase.IDLE,
-        description="Occurs when the agent successfully completes bootstrapping and is ready for input."
-    )
-    async def notify_initialization_complete(self) -> None:
-        if self.context.current_phase.is_initializing() or self.context.current_phase == AgentOperationalPhase.UNINITIALIZED:
-            # This will now be a BOOTSTRAPPING -> IDLE transition
-            await self._transition_phase(AgentOperationalPhase.IDLE, "notify_phase_idle_entered")
-        else:
-            logger.warning(f"Agent '{self.context.agent_id}' notify_initialization_complete called in unexpected phase: {self.context.current_phase.value}")
-
-    @phase_transition(
-        source_phases=[
-            AgentOperationalPhase.IDLE, AgentOperationalPhase.ANALYZING_LLM_RESPONSE,
-            AgentOperationalPhase.PROCESSING_TOOL_RESULT, AgentOperationalPhase.EXECUTING_TOOL,
-            AgentOperationalPhase.TOOL_DENIED
-        ],
-        target_phase=AgentOperationalPhase.PROCESSING_USER_INPUT,
-        description="Fires when the agent begins processing a new user message or inter-agent message."
-    )
-    async def notify_processing_input_started(self, trigger_info: Optional[str] = None) -> None:
-        if self.context.current_phase in [AgentOperationalPhase.IDLE, AgentOperationalPhase.ANALYZING_LLM_RESPONSE, AgentOperationalPhase.PROCESSING_TOOL_RESULT, AgentOperationalPhase.EXECUTING_TOOL, AgentOperationalPhase.TOOL_DENIED]:
-            data = {"trigger_info": trigger_info} if trigger_info else {}
-            await self._transition_phase(AgentOperationalPhase.PROCESSING_USER_INPUT, "notify_phase_processing_user_input_started", additional_data=data)
-        elif self.context.current_phase == AgentOperationalPhase.PROCESSING_USER_INPUT:
-             logger.debug(f"Agent '{self.context.agent_id}' already in PROCESSING_USER_INPUT phase.")
-        else:
-             logger.warning(f"Agent '{self.context.agent_id}' notify_processing_input_started called in unexpected phase: {self.context.current_phase.value}")
-
-    @phase_transition(
-        source_phases=[AgentOperationalPhase.PROCESSING_USER_INPUT, AgentOperationalPhase.PROCESSING_TOOL_RESULT],
-        target_phase=AgentOperationalPhase.AWAITING_LLM_RESPONSE,
-        description="Occurs just before the agent makes a call to the LLM."
-    )
-    async def notify_awaiting_llm_response(self) -> None:
-        await self._transition_phase(AgentOperationalPhase.AWAITING_LLM_RESPONSE, "notify_phase_awaiting_llm_response_started")
-
-    @phase_transition(
-        source_phases=[AgentOperationalPhase.AWAITING_LLM_RESPONSE],
-        target_phase=AgentOperationalPhase.ANALYZING_LLM_RESPONSE,
-        description="Occurs after the agent has received a complete response from the LLM and begins to analyze it."
-    )
-    async def notify_analyzing_llm_response(self) -> None:
-        await self._transition_phase(AgentOperationalPhase.ANALYZING_LLM_RESPONSE, "notify_phase_analyzing_llm_response_started")
-
-    @phase_transition(
-        source_phases=[AgentOperationalPhase.ANALYZING_LLM_RESPONSE],
-        target_phase=AgentOperationalPhase.AWAITING_TOOL_APPROVAL,
-        description="Occurs if the agent proposes a tool use that requires manual user approval."
-    )
-    async def notify_tool_execution_pending_approval(self, tool_invocation: 'ToolInvocation') -> None:
-        await self._transition_phase(AgentOperationalPhase.AWAITING_TOOL_APPROVAL, "notify_phase_awaiting_tool_approval_started")
-
-    @phase_transition(
-        source_phases=[AgentOperationalPhase.AWAITING_TOOL_APPROVAL],
-        target_phase=AgentOperationalPhase.EXECUTING_TOOL,
-        description="Occurs after a pending tool use has been approved and is about to be executed."
-    )
-    async def notify_tool_execution_resumed_after_approval(self, approved: bool, tool_name: Optional[str]) -> None:
-        if approved and tool_name:
-            await self._transition_phase(AgentOperationalPhase.EXECUTING_TOOL, "notify_phase_executing_tool_started", additional_data={"tool_name": tool_name})
-        else:
-            logger.info(f"Agent '{self.context.agent_id}' tool execution denied for '{tool_name}'. Transitioning to allow LLM to process denial.")
-            await self.notify_tool_denied(tool_name)
-
-    @phase_transition(
-        source_phases=[AgentOperationalPhase.AWAITING_TOOL_APPROVAL],
-        target_phase=AgentOperationalPhase.TOOL_DENIED,
-        description="Occurs after a pending tool use has been denied by the user."
-    )
-    async def notify_tool_denied(self, tool_name: Optional[str]) -> None:
-        """Notifies that a tool execution has been denied."""
-        await self._transition_phase(
-            AgentOperationalPhase.TOOL_DENIED,
-            "notify_phase_tool_denied_started",
-            additional_data={"tool_name": tool_name, "denial_for_tool": tool_name}
-        )
-
-    @phase_transition(
-        source_phases=[AgentOperationalPhase.ANALYZING_LLM_RESPONSE],
-        target_phase=AgentOperationalPhase.EXECUTING_TOOL,
-        description="Occurs when an agent with auto-approval executes a tool."
-    )
-    async def notify_tool_execution_started(self, tool_name: str) -> None:
-        await self._transition_phase(AgentOperationalPhase.EXECUTING_TOOL, "notify_phase_executing_tool_started", additional_data={"tool_name": tool_name})
-
-    @phase_transition(
-        source_phases=[AgentOperationalPhase.EXECUTING_TOOL],
-        target_phase=AgentOperationalPhase.PROCESSING_TOOL_RESULT,
-        description="Fires after a tool has finished executing and the agent begins processing its result."
-    )
-    async def notify_processing_tool_result(self, tool_name: str) -> None:
-        await self._transition_phase(AgentOperationalPhase.PROCESSING_TOOL_RESULT, "notify_phase_processing_tool_result_started", additional_data={"tool_name": tool_name})
-
-    @phase_transition(
-        source_phases=[
-            AgentOperationalPhase.PROCESSING_USER_INPUT, AgentOperationalPhase.ANALYZING_LLM_RESPONSE,
-            AgentOperationalPhase.PROCESSING_TOOL_RESULT
-        ],
-        target_phase=AgentOperationalPhase.IDLE,
-        description="Occurs when an agent completes a processing cycle and is waiting for new input."
-    )
-    async def notify_processing_complete_and_idle(self) -> None:
-        if not self.context.current_phase.is_terminal() and self.context.current_phase != AgentOperationalPhase.IDLE:
-            await self._transition_phase(AgentOperationalPhase.IDLE, "notify_phase_idle_entered")
-        elif self.context.current_phase == AgentOperationalPhase.IDLE:
-            logger.debug(f"Agent '{self.context.agent_id}' processing complete, already IDLE.")
-        else:
-            logger.warning(f"Agent '{self.context.agent_id}' notify_processing_complete_and_idle called in unexpected phase: {self.context.current_phase.value}")
-
-    @phase_transition(
-        source_phases=[
-            AgentOperationalPhase.UNINITIALIZED, AgentOperationalPhase.BOOTSTRAPPING, AgentOperationalPhase.IDLE,
-            AgentOperationalPhase.PROCESSING_USER_INPUT, AgentOperationalPhase.AWAITING_LLM_RESPONSE,
-            AgentOperationalPhase.ANALYZING_LLM_RESPONSE, AgentOperationalPhase.AWAITING_TOOL_APPROVAL,
-            AgentOperationalPhase.TOOL_DENIED, AgentOperationalPhase.EXECUTING_TOOL,
-            AgentOperationalPhase.PROCESSING_TOOL_RESULT, AgentOperationalPhase.SHUTTING_DOWN
-        ],
-        target_phase=AgentOperationalPhase.ERROR,
-        description="A catch-all transition that can occur from any non-terminal state if an unrecoverable error happens."
-    )
-    async def notify_error_occurred(self, error_message: str, error_details: Optional[str] = None) -> None:
-        if self.context.current_phase != AgentOperationalPhase.ERROR:
-            data = {"error_message": error_message, "error_details": error_details}
-            await self._transition_phase(AgentOperationalPhase.ERROR, "notify_phase_error_entered", additional_data=data)
-        else:
-            logger.debug(f"Agent '{self.context.agent_id}' already in ERROR phase when another error notified: {error_message}")
-
-    @phase_transition(
-        source_phases=[
-            AgentOperationalPhase.UNINITIALIZED, AgentOperationalPhase.BOOTSTRAPPING, AgentOperationalPhase.IDLE,
-            AgentOperationalPhase.PROCESSING_USER_INPUT, AgentOperationalPhase.AWAITING_LLM_RESPONSE,
-            AgentOperationalPhase.ANALYZING_LLM_RESPONSE, AgentOperationalPhase.AWAITING_TOOL_APPROVAL,
-            AgentOperationalPhase.TOOL_DENIED, AgentOperationalPhase.EXECUTING_TOOL,
-            AgentOperationalPhase.PROCESSING_TOOL_RESULT
-        ],
-        target_phase=AgentOperationalPhase.SHUTTING_DOWN,
-        description="Fires when the agent begins its graceful shutdown sequence."
-    )
-    async def notify_shutdown_initiated(self) -> None:
-        if not self.context.current_phase.is_terminal():
-             await self._transition_phase(AgentOperationalPhase.SHUTTING_DOWN, "notify_phase_shutting_down_started")
-        else:
-            logger.debug(f"Agent '{self.context.agent_id}' shutdown initiated but already in a terminal phase: {self.context.current_phase.value}")
-
-    @phase_transition(
-        source_phases=[AgentOperationalPhase.SHUTTING_DOWN],
-        target_phase=AgentOperationalPhase.SHUTDOWN_COMPLETE,
-        description="The final transition when the agent has successfully shut down and released its resources."
-    )
-    async def notify_final_shutdown_complete(self) -> None:
-        final_phase = AgentOperationalPhase.ERROR if self.context.current_phase == AgentOperationalPhase.ERROR else AgentOperationalPhase.SHUTDOWN_COMPLETE
-        if final_phase == AgentOperationalPhase.ERROR:
-            await self._transition_phase(AgentOperationalPhase.ERROR, "notify_phase_error_entered", additional_data={"error_message": "Shutdown completed with agent in error state."})
-        else:
-            await self._transition_phase(AgentOperationalPhase.SHUTDOWN_COMPLETE, "notify_phase_shutdown_completed")

autobyteus/agent/phases/transition_decorator.py

@@ -1,40 +0,0 @@
-# file: autobyteus/autobyteus/agent/phases/transition_decorator.py
-import functools
-from typing import List, Callable
-
-from .phase_enum import AgentOperationalPhase
-from .transition_info import PhaseTransitionInfo
-
-def phase_transition(
-    source_phases: List[AgentOperationalPhase],
-    target_phase: AgentOperationalPhase,
-    description: str
-) -> Callable:
-    """
-    A decorator to annotate methods in AgentPhaseManager that cause a phase transition.
-    
-    This decorator does not alter the method's execution. It attaches a
-    PhaseTransitionInfo object to the method, making the transition discoverable
-    via introspection.
-    
-    Args:
-        source_phases: A list of valid source phases from which this transition can occur.
-        target_phase: The phase the agent will be in after this transition.
-        description: A human-readable description of what causes this transition.
-    """
-    def decorator(func: Callable) -> Callable:
-        @functools.wraps(func)
-        def wrapper(*args, **kwargs):
-            return func(*args, **kwargs)
-
-        # Attach the metadata to the function object itself.
-        # We sort source phases for consistent representation.
-        sorted_sources = tuple(sorted(source_phases, key=lambda p: p.value))
-        setattr(wrapper, '_transition_info', PhaseTransitionInfo(
-            source_phases=sorted_sources,
-            target_phase=target_phase,
-            description=description,
-            triggering_method=func.__name__
-        ))
-        return wrapper
-    return decorator

autobyteus/agent/phases/transition_info.py

@@ -1,33 +0,0 @@
-# file: autobyteus/autobyteus/agent/phases/transition_info.py
-import logging
-from dataclasses import dataclass
-from typing import List, Tuple
-
-from .phase_enum import AgentOperationalPhase
-
-logger = logging.getLogger(__name__)
-
-@dataclass(frozen=True)
-class PhaseTransitionInfo:
-    """
-    A dataclass representing a valid, discoverable phase transition.
-    
-    This object provides the necessary metadata for users to understand what
-    kinds of phase hooks they can create.
-    
-    Attributes:
-        source_phases: A list of possible source phases for this transition.
-        target_phase: The single target phase for this transition.
-        description: A human-readable description of when this transition occurs.
-        triggering_method: The name of the method in AgentPhaseManager that triggers this.
-    """
-    source_phases: Tuple[AgentOperationalPhase, ...]
-    target_phase: AgentOperationalPhase
-    description: str
-    triggering_method: str
-
-    def __repr__(self) -> str:
-        sources = ", ".join(f"'{p.value}'" for p in self.source_phases)
-        return (f"<PhaseTransitionInfo sources=[{sources}] -> "
-                f"target='{self.target_phase.value}' "
-                f"triggered_by='{self.triggering_method}'>")

autobyteus/agent/remote_agent.py

@@ -1,244 +0,0 @@
-# file: autobyteus/autobyteus/agent/remote_agent.py
-import asyncio
-import logging
-import uuid # For generating default request IDs if ProtocolMessage doesn't
-from typing import Optional, Dict, Any, AsyncIterator
-
-from autobyteus.agent.agent import Agent 
-from autobyteus.agent.phases import AgentOperationalPhase
-from autobyteus.agent.message.agent_input_user_message import AgentInputUserMessage
-from autobyteus.agent.message.inter_agent_message import InterAgentMessage
-from autobyteus.rpc.client import default_client_connection_manager, AbstractClientConnection
-from autobyteus.rpc.protocol import ProtocolMessage, MessageType, RequestType, ResponseType, ErrorCode
-from autobyteus.rpc.config import AgentServerConfig, default_agent_server_registry
-from autobyteus.rpc.transport_type import TransportType # For type checking config
-
-
-logger = logging.getLogger(__name__)
-
-class RemoteAgentProxy(Agent):
-    """
-    Provides an Agent-like interface for interacting with a remote Agent Server.
-    It handles RPC communication and capability discovery.
-    Can target a specific agent on a multi-agent gateway server if target_agent_id_on_server is provided.
-    """
-    def __init__(self, 
-                 server_config_id: str, 
-                 target_agent_id_on_server: Optional[str] = None, # Added for multi-agent servers
-                 loop: Optional[asyncio.AbstractEventLoop] = None):
-        """
-        Initializes the RemoteAgentProxy.
-
-        Args:
-            server_config_id: The ID of the AgentServerConfig in the AgentServerRegistry
-                              that specifies how to connect to the remote agent server/gateway.
-            target_agent_id_on_server: Optional. If the server_config_id points to a multi-agent
-                                       gateway, this specifies the ID of the target agent on that
-                                       server. This ID is used for routing by the server.
-            loop: The asyncio event loop. If None, the running loop is used.
-        """
-        self.server_config_id: str = server_config_id
-        self.target_agent_id_on_server: Optional[str] = target_agent_id_on_server
-        
-        self._client_connection_manager = default_client_connection_manager
-        self._connection: Optional[AbstractClientConnection] = None
-        self._server_config: Optional[AgentServerConfig] = None # Will store the resolved config
-        self._loop = loop or asyncio.get_running_loop()
-
-        self._remote_agent_id_from_discovery: Optional[str] = None 
-        self._remote_capabilities: Dict[str, Any] = {} 
-        self._remote_status: AgentOperationalPhase = AgentOperationalPhase.UNINITIALIZED 
-
-        # For Agent compatibility:
-        # If target_agent_id_on_server is known, use it for a more descriptive initial proxy agent_id.
-        # This will be overwritten by the actual agent_id from discovery.
-        default_proxy_id_suffix = target_agent_id_on_server or server_config_id
-        self.agent_id: str = f"remote_proxy_for_{default_proxy_id_suffix}"
-        self.context = None 
-                            
-        self._is_initialized: bool = False
-        self._initialization_lock = asyncio.Lock()
-
-        logger.info(f"RemoteAgentProxy for server_id '{server_config_id}' (Targeting: {target_agent_id_on_server or 'N/A'}) created. Not yet initialized.")
-
-    async def _ensure_initialized(self):
-        async with self._initialization_lock:
-            if self._is_initialized:
-                return
-            
-            if not self._connection or not self._connection.is_connected:
-                logger.info(f"RemoteAgentProxy '{self.agent_id}': Attempting connection to server_config_id '{self.server_config_id}'.")
-                # Resolve server_config here as it's needed for SSE event URL construction too
-                self._server_config = default_agent_server_registry.get_config(self.server_config_id)
-                if not self._server_config:
-                    raise ValueError(f"AgentServerConfig not found for ID '{self.server_config_id}'.")
-                self._connection = await self._client_connection_manager.get_connection(self.server_config_id)
-            
-            await self._discover_capabilities() # This will use self.target_agent_id_on_server
-            self._is_initialized = True
-            logger.info(f"RemoteAgentProxy '{self.agent_id}' initialized. Discovered Remote Agent ID: '{self._remote_agent_id_from_discovery}'.")
-
-
-    async def _discover_capabilities(self):
-        if not self._connection:
-            raise ConnectionError("Cannot discover capabilities: not connected.")
-
-        params_for_discovery: Dict[str, Any] = {}
-        if self.target_agent_id_on_server:
-            params_for_discovery["target_agent_id"] = self.target_agent_id_on_server
-        
-        request_msg = ProtocolMessage.create_request(
-            method=RequestType.DISCOVER_CAPABILITIES,
-            params=params_for_discovery if params_for_discovery else None
-        )
-        logger.debug(f"RemoteAgentProxy '{self.agent_id}': Sending discover_capabilities request with params: {params_for_discovery}.")
-        
-        response_msg = await self._connection.send_request(request_msg)
-
-        if response_msg.type == MessageType.RESPONSE and response_msg.result:
-            self._remote_agent_id_from_discovery = response_msg.result.get("agent_id")
-            # Update proxy's agent_id to the actual discovered ID for better logging/identification
-            if self._remote_agent_id_from_discovery:
-                self.agent_id = self._remote_agent_id_from_discovery 
-            
-            self._remote_capabilities = response_msg.result.get("capabilities_details", {}) # Use detailed map
-            initial_status_str = response_msg.result.get("status") # 'status' key for legacy, but should be 'phase'
-            initial_phase_str = response_msg.result.get("phase", initial_status_str) # Prefer 'phase'
-            if initial_phase_str:
-                try: self._remote_status = AgentOperationalPhase(initial_phase_str)
-                except ValueError: logger.warning(f"Invalid phase '{initial_phase_str}' from discovery."); self._remote_status = AgentOperationalPhase.UNINITIALIZED
-            logger.info(f"RemoteAgentProxy (now ID: '{self.agent_id}'): Capabilities discovered. Remote Caps: {list(self._remote_capabilities.keys())}")
-        elif response_msg.type == MessageType.ERROR and response_msg.error:
-            err = response_msg.error
-            logger.error(f"RemoteAgentProxy '{self.agent_id}': Error discovering capabilities: {err.code} - {err.message}")
-            raise RuntimeError(f"Failed to discover remote agent capabilities: {err.message}")
-        else:
-            logger.error(f"RemoteAgentProxy '{self.agent_id}': Unexpected response during capability discovery: {response_msg.to_json_str()}")
-            raise RuntimeError("Unexpected response from remote agent during capability discovery.")
-
-    async def _invoke_remote_method(self, method_name: str, method_params: Optional[Dict[str, Any]] = None) -> Any:
-        await self._ensure_initialized()
-        if not self._connection: 
-            raise ConnectionError("Not connected to remote agent.")
-
-        # Construct parameters for the INVOKE_METHOD RPC call itself
-        rpc_params: Dict[str, Any] = {
-            "method_name": method_name,
-            "method_params": method_params or {}
-        }
-        if self.target_agent_id_on_server:
-            rpc_params["target_agent_id"] = self.target_agent_id_on_server
-        
-        request_msg = ProtocolMessage.create_request(
-            method=RequestType.INVOKE_METHOD,
-            params=rpc_params
-        )
-        log_method_params = str(method_params)[:100] + "..." if method_params and len(str(method_params)) > 100 else method_params
-        logger.debug(f"RemoteAgentProxy '{self.agent_id}': Invoking remote method '{method_name}' (Targeting: {self.target_agent_id_on_server or 'default'}) with params: {log_method_params}")
-        
-        response_msg = await self._connection.send_request(request_msg)
-
-        if response_msg.type == MessageType.RESPONSE:
-            logger.debug(f"RemoteAgentProxy '{self.agent_id}': Received successful response for '{method_name}'.")
-            return response_msg.result 
-        elif response_msg.type == MessageType.ERROR and response_msg.error:
-            err = response_msg.error
-            logger.error(f"RemoteAgentProxy '{self.agent_id}': Error invoking remote method '{method_name}': {err.code} - {err.message}")
-            raise RuntimeError(f"Error from remote agent on method '{method_name}': {err.message}")
-        else:
-            logger.error(f"RemoteAgentProxy '{self.agent_id}': Unexpected response invoking method '{method_name}': {response_msg.to_json_str()}")
-            raise RuntimeError(f"Unexpected response from remote agent invoking '{method_name}'.")
-
-    async def post_user_message(self, agent_input_user_message: AgentInputUserMessage) -> None:
-        params = {"agent_input_user_message": agent_input_user_message.to_dict()}
-        await self._invoke_remote_method("post_user_message", params)
-        logger.debug(f"RemoteAgentProxy '{self.agent_id}': post_user_message request sent.")
-
-    async def post_inter_agent_message(self, inter_agent_message: InterAgentMessage) -> None:
-        params = { "inter_agent_message": {
-                "recipient_role_name": inter_agent_message.recipient_role_name,
-                "recipient_agent_id": inter_agent_message.recipient_agent_id,
-                "content": inter_agent_message.content,
-                "message_type": str(inter_agent_message.message_type.value), 
-                "sender_agent_id": inter_agent_message.sender_agent_id,
-            }
-        }
-        await self._invoke_remote_method("post_inter_agent_message", params)
-        logger.debug(f"RemoteAgentProxy '{self.agent_id}': post_inter_agent_message request sent.")
-        
-    async def post_tool_execution_approval(self,
-                                         tool_invocation_id: str,
-                                         is_approved: bool,
-                                         reason: Optional[str] = None) -> None:
-        params = { "tool_invocation_id": tool_invocation_id, "is_approved": is_approved, "reason": reason}
-        await self._invoke_remote_method("post_tool_execution_approval", params)
-        logger.debug(f"RemoteAgentProxy '{self.agent_id}': post_tool_execution_approval sent.")
-
-    def get_current_phase(self) -> AgentOperationalPhase:
-        if not self._is_initialized:
-            logger.warning(f"RemoteAgentProxy '{self.agent_id}': get_current_phase called before initialization.")
-        # Returns cached status updated by discovery or potentially by SSE events.
-        return self._remote_status
-
-    @property
-    def is_running(self) -> bool:
-        # A remote agent is "running" if it's not in a terminal state or uninitialized.
-        if self._remote_status:
-            return not self._remote_status.is_terminal() and self._remote_status != AgentOperationalPhase.UNINITIALIZED
-        return False
-
-    def start(self) -> None:
-        # For RemoteAgentProxy, start() implies ensuring connection and readiness.
-        # The actual remote agent lifecycle is independent.
-        if not self._is_initialized:
-            logger.info(f"RemoteAgentProxy '{self.agent_id}': start() called. Ensuring initialization (async).")
-            if self._loop.is_running(): asyncio.create_task(self._ensure_initialized())
-            else:
-                try: self._loop.run_until_complete(self._ensure_initialized())
-                except RuntimeError as e: 
-                     if "cannot be nested" in str(e): logger.warning("RemoteAgentProxy.start() in sync context with running loop.")
-                     else: raise
-
-    async def stop(self, timeout: float = 10.0) -> None:
-        logger.info(f"RemoteAgentProxy '{self.agent_id}': stop() called. Closing connection to '{self.server_config_id}'.")
-        if self._connection:
-            await self._connection.close()
-            self._connection = None
-        self._is_initialized = False
-        self._remote_status = AgentOperationalPhase.SHUTDOWN_COMPLETE 
-
-    def get_event_queues(self): 
-        logger.warning("RemoteAgentProxy does not provide direct access to remote event queues.")
-        return None
-
-    async def stream_events(self) -> AsyncIterator[ProtocolMessage]:
-        """
-        Streams server-pushed events if connected via SSE.
-        """
-        await self._ensure_initialized() # Ensures self._connection and self._server_config are set
-        if not self._connection:
-            raise ConnectionError("Not connected to remote agent.")
-        if not self._server_config or self._server_config.transport_type != TransportType.SSE:
-            logger.warning(f"Event streaming only supported for SSE transport. Current: {self._server_config.transport_type if self._server_config else 'Unknown'}")
-            if False: yield # Make it an async generator
-            return
-        
-        logger.info(f"RemoteAgentProxy '{self.agent_id}': Starting to stream events (Target: {self.target_agent_id_on_server or 'default'}).")
-        async for event in self._connection.events():
-            # Update remote status if a phase transition event is received
-            if event.type == MessageType.EVENT and event.event_type == "agent_phase_transition" and event.payload:
-                new_phase_str = event.payload.get("new_phase")
-                if new_phase_str:
-                    try: 
-                        self._remote_status = AgentOperationalPhase(new_phase_str)
-                        logger.debug(f"RemoteAgentProxy '{self.agent_id}': Remote phase updated to {self._remote_status.value}")
-                    except ValueError: 
-                        logger.warning(f"Received invalid phase '{new_phase_str}' via SSE event.")
-            yield event
-
-
-    def __repr__(self) -> str:
-        conn_status = self._connection.is_connected if self._connection else False
-        return (f"<RemoteAgentProxy effective_id='{self.agent_id}' "
-                f"(DiscoveredRemoteID: {self._remote_agent_id_from_discovery or 'N/A'}) "
-                f"server_cfg='{self.server_config_id}' target_on_server='{self.target_agent_id_on_server or 'N/A'}' connected={conn_status}>")

autobyteus/agent/workspace/workspace_definition.py

@@ -1,36 +0,0 @@
-"""
-This module defines the WorkspaceDefinition class, which encapsulates the metadata
-for a specific type of agent workspace.
-"""
-import logging
-from typing import Type, Optional, TYPE_CHECKING
-from autobyteus.utils.parameter_schema import ParameterSchema
-
-if TYPE_CHECKING:
-    from autobyteus.agent.workspace.base_workspace import BaseAgentWorkspace
-
-logger = logging.getLogger(__name__)
-
-class WorkspaceDefinition:
-    """Represents the definition of a discoverable and creatable agent workspace type."""
-    def __init__(self,
-                 workspace_type_name: str,
-                 description: str,
-                 workspace_class: Type['BaseAgentWorkspace'],
-                 config_schema: ParameterSchema):
-        if not all([workspace_type_name, description, workspace_class, config_schema is not None]):
-            raise ValueError("All parameters for WorkspaceDefinition are required.")
-
-        self.workspace_type_name = workspace_type_name
-        self.description = description
-        self.workspace_class = workspace_class
-        self.config_schema = config_schema
-        logger.debug(f"WorkspaceDefinition created for type '{workspace_type_name}'.")
-
-    def to_dict(self) -> dict:
-        """Serializes the definition to a dictionary for API exposure."""
-        return {
-            "workspace_type_name": self.workspace_type_name,
-            "description": self.description,
-            "config_schema": self.config_schema.to_dict()
-        }

autobyteus/agent/workspace/workspace_meta.py

@@ -1,37 +0,0 @@
-"""
-This module contains the metaclass for BaseAgentWorkspace for automatic registration.
-"""
-import logging
-from abc import ABCMeta
-from .workspace_registry import default_workspace_registry
-from .workspace_definition import WorkspaceDefinition
-
-logger = logging.getLogger(__name__)
-
-class WorkspaceMeta(ABCMeta):
-    """Metaclass to automatically register concrete BaseAgentWorkspace subclasses."""
-    def __init__(cls, name, bases, dct):
-        super().__init__(name, bases, dct)
-        
-        if name == 'BaseAgentWorkspace' or getattr(cls, "__abstractmethods__", None):
-            logger.debug(f"Skipping registration for abstract workspace class: {name}")
-            return
-
-        try:
-            workspace_type_name = cls.get_workspace_type_name()
-            description = cls.get_description()
-            config_schema = cls.get_config_schema()
-            
-            definition = WorkspaceDefinition(
-                workspace_type_name=workspace_type_name,
-                description=description,
-                workspace_class=cls,
-                config_schema=config_schema
-            )
-            default_workspace_registry.register(definition)
-            config_params_info = f"config_params: {len(config_schema) if config_schema else 0}"
-            logger.info(f"Auto-registered workspace: '{workspace_type_name}' from class {name} ({config_params_info})")
-        except AttributeError as e:
-            logger.error(f"Workspace class {name} is missing a required static/class method ({e}). Skipping registration.")
-        except Exception as e:
-            logger.error(f"Failed to auto-register workspace class {name}: {e}", exc_info=True)