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

autobyteus/person/examples/sample_roles.py

@@ -1,14 +0,0 @@
-from autobyteus.person.role import Role
-
-
-RESEARCHER_ROLE = Role(
-    name="Researcher",
-    skills=["data analysis", "literature review", "critical thinking"],
-    responsibilities=["gather information", "analyze data", "report findings"]
-)
-
-WRITER_ROLE = Role(
-    name="Writer",
-    skills=["content creation", "editing", "storytelling"],
-    responsibilities=["draft articles", "revise content", "adapt to different styles"]
-)

autobyteus/person/person.py

@@ -1,29 +0,0 @@
-from typing import List
-from autobyteus.person.role import Role
-
-class Person:
-    def __init__(self, name: str, role: Role, characteristics: List[str]):
-        self.name = name
-        self.role = role
-        self.characteristics = characteristics
-        self.tasks = []
-
-    def get_description(self) -> str:
-        characteristics_str = ", ".join(self.characteristics)
-        return (f"Person: {self.name}\n"
-                f"{self.role.get_description()}\n"
-                f"Characteristics: {characteristics_str}")
-
-    def __str__(self) -> str:
-        return f"{self.name} ({self.role.name})"
-
-    def assign_task(self, task):
-        if task not in self.tasks:
-            self.tasks.append(task)
-
-    def unassign_task(self, task):
-        if task in self.tasks:
-            self.tasks.remove(task)
-
-    def get_tasks(self):
-        return self.tasks

autobyteus/person/role.py

@@ -1,14 +0,0 @@
-from typing import List
-
-class Role:
-    def __init__(self, name: str, skills: List[str], responsibilities: List[str]):
-        self.name = name
-        self.skills = skills
-        self.responsibilities = responsibilities
-
-    def get_description(self) -> str:
-        skills_str = ", ".join(self.skills)
-        responsibilities_str = ", ".join(self.responsibilities)
-        return (f"Role: {self.name}\n"
-                f"Skills: {skills_str}\n"
-                f"Responsibilities: {responsibilities_str}")

autobyteus/rpc/__init__.py

@@ -1,73 +0,0 @@
-# file: autobyteus/autobyteus/rpc/__init__.py
-"""
-AutoByteUs Remote Procedure Call (RPC) Framework.
-
-This package provides components for enabling communication between AutoByteUs agents
-running in separate processes or on different machines. It includes:
-- Protocol definitions for structured messaging.
-- Configuration management for RPC servers.
-- Client-side components for connecting to and interacting with remote agents.
-- Server-side components for exposing an agent's capabilities remotely.
-- High-level hosting utilities for easily serving agents.
-"""
-
-from .protocol import ProtocolMessage, MessageType, RequestType, ResponseType, ErrorCode, ErrorDetails, EventType
-from .transport_type import TransportType
-from .config import AgentServerConfig, AgentServerRegistry, default_agent_server_registry
-from .client import (
-    AbstractClientConnection,
-    StdioClientConnection,
-    SseClientConnection, 
-    ClientConnectionManager,
-    default_client_connection_manager
-)
-from .server import (
-    AgentServerEndpoint,
-    StdioServerHandler, 
-    SseServerHandler, 
-    BaseMethodHandler, 
-    DiscoverCapabilitiesHandler, 
-    InvokeMethodHandler,
-    InitiateStreamDownloadHandler # Added InitiateStreamDownloadHandler
-)
-from .hosting import serve_agent_stdio, serve_agent_http_sse, serve_single_agent_http_sse, serve_multiple_agents_http_sse # Added all hosting functions
-
-# RemoteAgentProxy is part of the agent package, but closely related
-# from ..agent.remote_agent import RemoteAgentProxy 
-
-__all__ = [
-    # Protocol
-    "ProtocolMessage",
-    "MessageType",
-    "RequestType",
-    "ResponseType",
-    "ErrorCode",
-    "ErrorDetails",
-    "EventType", 
-    # Transport
-    "TransportType",
-    # Config
-    "AgentServerConfig",
-    "AgentServerRegistry",
-    "default_agent_server_registry",
-    # Client
-    "AbstractClientConnection",
-    "StdioClientConnection",
-    "SseClientConnection", 
-    "ClientConnectionManager",
-    "default_client_connection_manager",
-    # Server
-    "AgentServerEndpoint",
-    "StdioServerHandler", 
-    "SseServerHandler",   
-    "BaseMethodHandler",  
-    "DiscoverCapabilitiesHandler", 
-    "InvokeMethodHandler",
-    "InitiateStreamDownloadHandler", # Added
-    # Hosting
-    "serve_agent_stdio", 
-    "serve_agent_http_sse", # Main alias
-    "serve_single_agent_http_sse", # Specific for one agent
-    "serve_multiple_agents_http_sse", # Specific for multiple agents
-]
-

autobyteus/rpc/client/__init__.py

@@ -1,17 +0,0 @@
-# file: autobyteus/autobyteus/rpc/client/__init__.py
-"""
-Client-side components for the AutoByteUs RPC framework.
-These components are used to connect to and interact with remote Agent Servers.
-"""
-from .abstract_client_connection import AbstractClientConnection
-from .stdio_client_connection import StdioClientConnection
-from .sse_client_connection import SseClientConnection # Added SseClientConnection
-from .client_connection_manager import ClientConnectionManager, default_client_connection_manager
-
-__all__ = [
-    "AbstractClientConnection",
-    "StdioClientConnection",
-    "SseClientConnection", # Added SseClientConnection to exports
-    "ClientConnectionManager",
-    "default_client_connection_manager",
-]

autobyteus/rpc/client/abstract_client_connection.py

@@ -1,124 +0,0 @@
-# file: autobyteus/autobyteus/rpc/client/abstract_client_connection.py
-import asyncio
-import logging
-from abc import ABC, abstractmethod
-from typing import AsyncIterator, Optional, Dict, Any # Added Dict, Any
-
-from autobyteus.rpc.protocol import ProtocolMessage
-
-logger = logging.getLogger(__name__)
-
-class AbstractClientConnection(ABC):
-    """
-    Abstract base class for client-side connections to an Agent Server.
-    Defines the common interface for sending requests and handling responses/events.
-    """
-
-    def __init__(self, server_id: str):
-        self.server_id = server_id
-        self._is_connected: bool = False
-        self._connection_lock = asyncio.Lock()
-
-    @property
-    def is_connected(self) -> bool:
-        """Indicates if the connection is currently active."""
-        return self._is_connected
-
-    @abstractmethod
-    async def connect(self) -> None:
-        """
-        Establishes the connection to the remote server.
-        Sets _is_connected to True on success.
-        Raises:
-            ConnectionError: If connection fails.
-        """
-        raise NotImplementedError
-
-    @abstractmethod
-    async def close(self) -> None:
-        """
-        Closes the connection to the remote server.
-        Sets _is_connected to False.
-        """
-        raise NotImplementedError
-
-    @abstractmethod
-    async def send_request(self, request_message: ProtocolMessage) -> ProtocolMessage:
-        """
-        Sends a request ProtocolMessage to the server and awaits a corresponding
-        response ProtocolMessage (either a result or an error).
-
-        Args:
-            request_message: The ProtocolMessage to send (must be of type REQUEST).
-
-        Returns:
-            The response ProtocolMessage from the server.
-
-        Raises:
-            ConnectionError: If not connected or if communication fails.
-            TimeoutError: If the server does not respond within a reasonable time.
-            ValueError: If request_message is not a valid request.
-        """
-        raise NotImplementedError
-
-    async def events(self) -> AsyncIterator[ProtocolMessage]: # pragma: no cover
-        """
-        (Optional for some connection types like stdio, primary for SSE)
-        Provides an asynchronous iterator for server-pushed events.
-
-        Yields:
-            ProtocolMessage objects of type EVENT from the server.
-
-        Raises:
-            ConnectionError: If not connected or if the event stream fails.
-        """
-        # Default implementation for connection types that don't support server-pushed events.
-        if False: # This makes the method an async generator while doing nothing
-            yield
-        logger.warning(f"Connection type {self.__class__.__name__} does not support server-pushed events via events().")
-        return
-
-
-    @abstractmethod
-    async def request_and_download_stream(
-        self, 
-        stream_request_params: Dict[str, Any],
-        target_agent_id: str
-    ) -> AsyncIterator[bytes]: # pragma: no cover
-        """
-        Requests a stream download from the server and then streams the data.
-        This typically involves a two-step process:
-        1. An RPC call to initiate the stream download and get a download URL.
-        2. An HTTP GET request to the download URL to fetch the stream.
-
-        Args:
-            stream_request_params: Parameters for the REQUEST_STREAM_DOWNLOAD RPC call,
-                                   e.g., `{"resource_id": "some_file"}`.
-            target_agent_id: The ID of the target agent on the server that owns/provides the stream.
-                             This is used to construct the `target_agent_id` field in the RPC request params.
-
-        Yields:
-            bytes: Chunks of the downloaded data.
-
-        Raises:
-            ConnectionError: If not connected or if communication fails.
-            ValueError: If the server response for stream initiation is invalid.
-            NotImplementedError: If the connection type does not support this.
-        """
-        # Default implementation for connection types that don't support this.
-        if False: # Makes it an async generator
-            yield b'' 
-        logger.warning(f"Connection type {self.__class__.__name__} does not support request_and_download_stream().")
-        raise NotImplementedError(f"{self.__class__.__name__} does not support stream downloads.")
-
-
-    async def __aenter__(self):
-        await self.connect()
-        return self
-
-    async def __aexit__(self, exc_type, exc_val, exc_tb):
-        await self.close()
-
-    def __repr__(self) -> str:
-        return f"<{self.__class__.__name__} server_id='{self.server_id}', connected={self.is_connected}>"
-

autobyteus/rpc/client/client_connection_manager.py

@@ -1,153 +0,0 @@
-# file: autobyteus/autobyteus/rpc/client/client_connection_manager.py
-import logging
-from typing import Dict, Optional
-
-from autobyteus.utils.singleton import SingletonMeta
-from autobyteus.rpc.config import AgentServerConfig, AgentServerRegistry, default_agent_server_registry
-from autobyteus.rpc.transport_type import TransportType
-from .abstract_client_connection import AbstractClientConnection
-from .stdio_client_connection import StdioClientConnection
-from .sse_client_connection import SseClientConnection # Import SseClientConnection
-
-logger = logging.getLogger(__name__)
-
-class ClientConnectionManager(metaclass=SingletonMeta):
-    """
-    Manages the creation and caching of AbstractClientConnection instances.
-    Uses AgentServerRegistry to find server configurations.
-    """
-
-    def __init__(self, agent_server_registry: AgentServerRegistry = default_agent_server_registry):
-        self._agent_server_registry: AgentServerRegistry = agent_server_registry
-        self._active_connections: Dict[str, AbstractClientConnection] = {} # Cache connections by server_id
-        logger.info("ClientConnectionManager initialized.")
-
-    async def get_connection(self, server_config_id: str) -> AbstractClientConnection:
-        """
-        Gets or creates a client connection for the given server configuration ID.
-        If a connection for this ID already exists and is connected, it's returned.
-        Otherwise, a new connection is established.
-
-        Args:
-            server_config_id: The ID of the AgentServerConfig to connect to.
-
-        Returns:
-            An AbstractClientConnection instance.
-
-        Raises:
-            ValueError: If server_config_id is not found or config is invalid.
-            ConnectionError: If establishing a new connection fails.
-        """
-        if server_config_id in self._active_connections:
-            conn = self._active_connections[server_config_id]
-            if conn.is_connected: 
-                logger.debug(f"Returning cached and connected connection for '{server_config_id}'.")
-                return conn
-            else:
-                logger.info(f"Cached connection for '{server_config_id}' found but not connected. Attempting to recreate.")
-                await self.close_connection(server_config_id)
-
-
-        server_config: Optional[AgentServerConfig] = self._agent_server_registry.get_config(server_config_id)
-        if not server_config:
-            raise ValueError(f"AgentServerConfig not found in registry for server_id: '{server_config_id}'.")
-
-        connection: AbstractClientConnection
-        if server_config.transport_type == TransportType.STDIO:
-            connection = StdioClientConnection(server_config)
-        elif server_config.transport_type == TransportType.SSE:
-            connection = SseClientConnection(server_config) # Added SSE case
-        else:
-            raise NotImplementedError(f"Unsupported transport type '{server_config.transport_type}' for server_id '{server_config_id}'.")
-
-        try:
-            await connection.connect()
-            self._active_connections[server_config_id] = connection
-            logger.info(f"Successfully established new connection for server_id '{server_config_id}' type '{server_config.transport_type}'.")
-            return connection
-        except Exception as e:
-            logger.error(f"Failed to establish connection for server_id '{server_config_id}': {e}", exc_info=True)
-            await connection.close() # Ensure cleanup on failed connect
-            if server_config_id in self._active_connections:
-                 del self._active_connections[server_config_id]
-            raise ConnectionError(f"Failed to connect to server '{server_config_id}': {e}") from e
-
-
-    async def close_connection(self, server_config_id: str) -> None:
-        """
-        Closes and removes a specific connection from the manager.
-
-        Args:
-            server_config_id: The ID of the server connection to close.
-        """
-        connection = self._active_connections.pop(server_config_id, None)
-        if connection:
-            logger.info(f"Closing connection for server_id '{server_config_id}'.")
-            try:
-                await connection.close()
-            except Exception as e:
-                logger.error(f"Error closing connection for server_id '{server_config_id}': {e}", exc_info=True)
-        else:
-            logger.debug(f"No active connection found for server_id '{server_config_id}' to close.")
-
-    async def close_all_connections(self) -> None:
-        """Closes all active connections managed by this instance."""
-        logger.info(f"Closing all {len(self._active_connections)} active connections.")
-        for server_id in list(self._active_connections.keys()):
-            await self.close_connection(server_id)
-        logger.info("All active connections have been requested to close.")
-
-default_client_connection_manager = ClientConnectionManager()
-
-if __name__ == "__main__": # pragma: no cover
-    logging.basicConfig(level=logging.DEBUG)
-    
-    # Mock server configs
-    mock_stdio_id = "mock_stdio_ccm"
-    mock_stdio_cfg = AgentServerConfig(
-        server_id=mock_stdio_id,
-        transport_type=TransportType.STDIO,
-        stdio_command=["python", "-c", "import sys, time, json; print(json.dumps({'type':'response', 'id':'1', 'result':{'status':'ok'}}), flush=True); time.sleep(0.1); sys.exit(0)"]
-    )
-    default_agent_server_registry.register_config(mock_stdio_cfg)
-
-    mock_sse_id = "mock_sse_ccm"
-    mock_sse_cfg = AgentServerConfig(
-        server_id=mock_sse_id,
-        transport_type=TransportType.SSE,
-        sse_base_url="http://localhost:12345", # Dummy URL, server won't actually run here
-        sse_request_endpoint="/rpc",
-        sse_events_endpoint="/stream"
-    )
-    default_agent_server_registry.register_config(mock_sse_cfg)
-
-
-    manager = default_client_connection_manager
-
-    async def main_ccm_test():
-        stdio_conn = None
-        sse_conn = None
-        try:
-            logger.info(f"Testing CCM with Stdio: {mock_stdio_id}")
-            stdio_conn = await manager.get_connection(mock_stdio_id)
-            logger.info(f"Stdio connection: {stdio_conn}")
-            if stdio_conn.is_connected:
-                # Test send_request on stdio_conn
-                req = ProtocolMessage.create_request(method="test", id="1")
-                resp = await stdio_conn.send_request(req)
-                logger.info(f"Stdio test response: {resp}")
-
-
-            logger.info(f"Testing CCM with SSE: {mock_sse_id}")
-            sse_conn = await manager.get_connection(mock_sse_id) # This will create SseClientConnection and its session
-            logger.info(f"SSE connection: {sse_conn}")
-            # Actual SSE requests would fail here as no server is running at localhost:12345
-
-        except Exception as e:
-            logger.error(f"Error in CCM main_ccm_test: {e}", exc_info=True)
-        finally:
-            logger.info("Closing all connections via CCM.")
-            await manager.close_all_connections()
-            default_agent_server_registry.clear() # Clean up registry for other tests if any
-
-    asyncio.run(main_ccm_test())