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

autobyteus/rpc/client/sse_client_connection.py

@@ -1,306 +0,0 @@
-# file: autobyteus/autobyteus/rpc/client/sse_client_connection.py
-import asyncio
-import logging
-import json
-from typing import Optional, AsyncIterator, Dict, Any # Added Dict, Any
-
-import aiohttp
-from aiohttp_sse_client.client import EventSource # type: ignore
-
-from autobyteus.rpc.protocol import ProtocolMessage, MessageType, ErrorCode, EventType, RequestType, ResponseType # Added RequestType, ResponseType
-from .abstract_client_connection import AbstractClientConnection
-from autobyteus.rpc.config import AgentServerConfig, TransportType # Added TransportType from config
-
-logger = logging.getLogger(__name__)
-
-DEFAULT_SSE_TIMEOUT = 30.0  # seconds for an HTTP request response
-DEFAULT_SSE_RECONNECTION_TIME = 5 # seconds
-DEFAULT_STREAM_DOWNLOAD_TIMEOUT = 300.0 # 5 minutes for stream download requests
-
-class SseClientConnection(AbstractClientConnection):
-    """
-    Client connection implementation for SSE-based Agent Servers.
-    Uses aiohttp for HTTP requests and aiohttp-sse-client for consuming SSE event streams.
-    Also supports direct HTTP stream downloads.
-    """
-
-    def __init__(self, server_config: AgentServerConfig):
-        """
-        Initializes the SseClientConnection.
-
-        Args:
-            server_config: The configuration for the SSE server.
-
-        Raises:
-            ValueError: If server_config is not for SSE or base URL is missing.
-        """
-        if server_config.transport_type != TransportType.SSE: # Use Enum member
-            raise ValueError("SseClientConnection requires an AgentServerConfig with transport_type 'sse'.")
-        if not server_config.sse_base_url:
-            raise ValueError("AgentServerConfig for sse transport must have an sse_base_url.")
-
-        super().__init__(server_id=server_config.server_id)
-        self.server_config: AgentServerConfig = server_config
-        self._session: Optional[aiohttp.ClientSession] = None
-        self._event_source: Optional[EventSource] = None
-
-    async def connect(self) -> None:
-        """
-        Establishes the aiohttp ClientSession. For SSE, actual connection
-        to event stream happens when events() is iterated.
-        """
-        async with self._connection_lock:
-            if self._is_connected and self._session and not self._session.closed:
-                logger.debug(f"SseClientConnection to '{self.server_id}' session already active.")
-                return
-
-            try:
-                # Create a new session if it doesn't exist or is closed
-                if not self._session or self._session.closed:
-                    self._session = aiohttp.ClientSession()
-                    logger.info(f"SseClientConnection to '{self.server_id}': new aiohttp.ClientSession created.")
-                
-                self._is_connected = True # Mark as connected once session is ready
-                logger.info(f"SseClientConnection to '{self.server_id}' connected (session ready).")
-            except Exception as e:
-                logger.error(f"Failed to create/ensure aiohttp.ClientSession for '{self.server_id}': {e}", exc_info=True)
-                self._is_connected = False
-                if self._session and not self._session.closed:
-                    await self._session.close()
-                self._session = None
-                raise ConnectionError(f"Failed to initialize HTTP session for SSE server '{self.server_id}': {e}") from e
-
-    async def close(self) -> None:
-        """Closes the aiohttp ClientSession and any active EventSource."""
-        async with self._connection_lock:
-            if not self._is_connected and not self._session: # Check both state and session object
-                logger.debug(f"SseClientConnection to '{self.server_id}' already closed or never connected.")
-                return
-            
-            self._is_connected = False 
-
-            if self._event_source:
-                try:
-                    await self._event_source.close()
-                    logger.debug(f"EventSource for '{self.server_id}' closed.")
-                except Exception as e:
-                    logger.error(f"Error closing EventSource for '{self.server_id}': {e}", exc_info=True)
-                self._event_source = None
-
-            if self._session and not self._session.closed:
-                try:
-                    await self._session.close()
-                    logger.debug(f"aiohttp.ClientSession for '{self.server_id}' closed.")
-                except Exception as e:
-                    logger.error(f"Error closing aiohttp.ClientSession for '{self.server_id}': {e}", exc_info=True)
-            self._session = None # Ensure session object is cleared
-            
-            logger.info(f"SseClientConnection to '{self.server_id}' closed.")
-
-    async def send_request(self, request_message: ProtocolMessage) -> ProtocolMessage:
-        """Sends a request via HTTP POST and awaits a JSON response."""
-        if not self._is_connected or not self._session or self._session.closed:
-            logger.info(f"SseClientConnection '{self.server_id}' not connected or session closed/missing. Attempting to connect before send_request.")
-            await self.connect() 
-            if not self._is_connected or not self._session or self._session.closed: # Check again after connect attempt
-                raise ConnectionError(f"Failed to connect to SSE server '{self.server_id}' for send_request (connection attempt failed).")
-
-        if request_message.type != MessageType.REQUEST:
-            raise ValueError("ProtocolMessage must be of type REQUEST to be sent via send_request.")
-        if not request_message.id:
-            raise ValueError("Request ProtocolMessage must have an ID.")
-
-        request_url = self.server_config.get_sse_full_request_url()
-        if not request_url: 
-            raise ValueError("SSE request URL is not configured.")
-
-        logger.debug(f"SseClient '{self.server_id}' sending request to {request_url}: {request_message.to_json_str()}")
-        
-        try:
-            async with self._session.post(
-                request_url,
-                json=request_message.model_dump(exclude_none=True), 
-                timeout=DEFAULT_SSE_TIMEOUT
-            ) as response:
-                response_text = await response.text()
-                if response.status >= 200 and response.status < 300:
-                    try:
-                        return ProtocolMessage.from_json_str(response_text)
-                    except (json.JSONDecodeError, ValueError) as e: 
-                        logger.error(f"Error decoding JSON response from '{request_url}': {e}. Response text: {response_text[:200]}")
-                        return ProtocolMessage.create_error_response(
-                            id=request_message.id,
-                            code=ErrorCode.PARSE_ERROR,
-                            message=f"Failed to parse JSON response from server: {e}"
-                        )
-                else:
-                    logger.error(f"HTTP error from '{request_url}': {response.status} {response.reason}. Response: {response_text[:200]}")
-                    return ProtocolMessage.create_error_response(
-                        id=request_message.id,
-                        code=ErrorCode.INTERNAL_ERROR, 
-                        message=f"Server returned HTTP error {response.status}: {response.reason}. Body: {response_text[:200]}"
-                    )
-        except aiohttp.ClientConnectorError as e:
-            logger.error(f"Connection error for '{request_url}': {e}", exc_info=True)
-            await self.close() # Connection is likely broken, perform full close
-            raise ConnectionError(f"Could not connect to SSE server at '{request_url}': {e}") from e
-        except asyncio.TimeoutError:
-            logger.warning(f"Timeout sending request to '{request_url}' for ID '{request_message.id}'.")
-            # Don't necessarily close connection on timeout, server might be slow.
-            return ProtocolMessage.create_error_response(
-                id=request_message.id,
-                code=ErrorCode.SERVER_ERROR_TIMEOUT,
-                message=f"Timeout waiting for response from SSE server for request ID '{request_message.id}'."
-            )
-        except Exception as e:
-            logger.error(f"Unexpected error sending request to '{request_url}': {e}", exc_info=True)
-            if isinstance(e, (aiohttp.ClientError)): 
-                 await self.close() # If it's a client lib error, connection might be compromised
-            return ProtocolMessage.create_error_response(
-                id=request_message.id,
-                code=ErrorCode.INTERNAL_ERROR,
-                message=f"Client-side error sending request: {e}"
-            )
-
-    async def events(self) -> AsyncIterator[ProtocolMessage]:
-        """Connects to the SSE event stream and yields ProtocolMessages."""
-        if not self._is_connected or not self._session or self._session.closed:
-            logger.info(f"SseClientConnection '{self.server_id}' session not found or closed, attempting to connect before streaming events.")
-            await self.connect()
-            if not self._is_connected or not self._session or self._session.closed: # Check again
-                 raise ConnectionError(f"Not connected to SSE server '{self.server_id}' for event streaming (connection attempt failed).")
-
-        # Construct event URL. Note: SseServerHandler expects /events/{agent_id_on_server}
-        # The client config's server_id typically maps to an agent_id_on_server or is the agent_id_on_server.
-        # For multi-agent servers, the client needs to know which agent_id_on_server to subscribe to.
-        # This implies server_config.server_id is the agent_id_on_server for SSE event subscriptions.
-        base_events_url = self.server_config.get_sse_full_events_url()
-        if not base_events_url: # This is base path like /events
-             raise ValueError("SSE events base URL path is not configured.")
-        
-        # Assuming self.server_id (from config) is the key for the agent on the server.
-        events_url = f"{base_events_url.rstrip('/')}/{self.server_id}"
-        logger.info(f"SseClient '{self.server_id}' connecting to event stream at {events_url}")
-        
-        if self._event_source: # Close existing if any
-            await self._event_source.close()
-            self._event_source = None
-
-        try:
-            self._event_source = EventSource(
-                events_url,
-                session=self._session, # Use existing session
-                reconnection_time=DEFAULT_SSE_RECONNECTION_TIME,
-            )
-            await self._event_source.connect() 
-
-            async for sse_event in self._event_source:
-                try:
-                    logger.debug(f"SseClient '{self.server_id}' received SSE event data: {sse_event.data[:200]}")
-                    msg = ProtocolMessage.from_json_str(sse_event.data)
-                    if msg.type == MessageType.EVENT:
-                        yield msg
-                    else:
-                        logger.warning(f"Received non-EVENT ProtocolMessage via SSE stream: {msg.type}. Ignoring.")
-                except json.JSONDecodeError as e:
-                    logger.error(f"Error decoding JSON from SSE event data: {e}. Data: {sse_event.data[:200]}")
-                except ValueError as e: 
-                    logger.error(f"Error validating ProtocolMessage from SSE event data: {e}. Data: {sse_event.data[:200]}")
-                except Exception as e:
-                    logger.error(f"Error processing SSE event: {e}", exc_info=True)
-
-        except ConnectionRefusedError as e:
-            logger.error(f"SSE EventStream for '{self.server_id}' connection refused at {events_url}: {e}")
-            await self.close()
-            raise ConnectionError(f"SSE EventStream connection refused: {e}") from e
-        except aiohttp.ClientError as e: 
-            logger.error(f"SSE EventStream client error for '{self.server_id}' at {events_url}: {e}", exc_info=True)
-            await self.close() 
-            raise ConnectionError(f"SSE EventStream client error: {e}") from e
-        except asyncio.CancelledError:
-            logger.info(f"SSE event stream for '{self.server_id}' cancelled.")
-            if self._event_source: await self._event_source.close()
-            raise
-        except Exception as e:
-            logger.error(f"Unexpected error in SSE event stream for '{self.server_id}': {e}", exc_info=True)
-            if self._event_source: await self._event_source.close()
-            await self.close()
-            raise ConnectionError(f"Unexpected error in SSE event stream: {e}") from e
-        finally:
-            logger.info(f"SseClient '{self.server_id}' event stream iteration finished.")
-            if self._event_source: 
-                await self._event_source.close()
-                self._event_source = None
-
-
-    async def request_and_download_stream(
-        self, 
-        stream_request_params: Dict[str, Any],
-        target_agent_id: str # This is the agent_id_on_server key
-    ) -> AsyncIterator[bytes]:
-        """
-        Requests a stream download via RPC and then downloads the stream via HTTP GET.
-        """
-        if not self._is_connected or not self._session or self._session.closed:
-            logger.info(f"SseClientConnection '{self.server_id}' not connected or session closed/missing. Attempting to connect before stream download.")
-            await self.connect()
-            if not self._is_connected or not self._session or self._session.closed:
-                raise ConnectionError(f"Failed to connect to SSE server '{self.server_id}' for stream download (connection attempt failed).")
-
-        # Step 1: RPC call to initiate stream download
-        # The target_agent_id for the stream must be included in the params for the RPC call.
-        rpc_params = {**stream_request_params, "target_agent_id": target_agent_id}
-        initiate_request_msg = ProtocolMessage.create_request(
-            method=RequestType.REQUEST_STREAM_DOWNLOAD,
-            params=rpc_params
-        )
-        
-        logger.debug(f"SseClient '{self.server_id}' sending stream download initiation request for target_agent_id '{target_agent_id}': {initiate_request_msg.to_json_str()}")
-        
-        initiate_response_msg = await self.send_request(initiate_request_msg)
-
-        if initiate_response_msg.type == MessageType.ERROR or not initiate_response_msg.result:
-            err_details = initiate_response_msg.error.message if initiate_response_msg.error else "Unknown error"
-            logger.error(f"Failed to initiate stream download for target_agent_id '{target_agent_id}'. Server error: {err_details}")
-            raise ValueError(f"Server error initiating stream download: {err_details}")
-
-        if initiate_response_msg.response_type != ResponseType.STREAM_DOWNLOAD_READY:
-            logger.error(f"Unexpected response type from stream download initiation: {initiate_response_msg.response_type}")
-            raise ValueError(f"Unexpected response type: {initiate_response_msg.response_type}")
-
-        download_url = initiate_response_msg.result.get("download_url")
-        if not download_url:
-            logger.error(f"No 'download_url' in STREAM_DOWNLOAD_READY response. Result: {initiate_response_msg.result}")
-            raise ValueError("Server response did not include a download_url for the stream.")
-
-        stream_metadata = initiate_response_msg.result.get("metadata", {})
-        logger.info(f"SseClient '{self.server_id}' received download URL: {download_url}. Metadata: {stream_metadata}")
-
-        # Step 2: HTTP GET request to the download_url
-        try:
-            logger.debug(f"SseClient '{self.server_id}' starting GET request to stream from {download_url}")
-            async with self._session.get(download_url, timeout=DEFAULT_STREAM_DOWNLOAD_TIMEOUT) as response:
-                response.raise_for_status() # Raise an exception for HTTP error codes (4xx or 5xx)
-                
-                # Stream the content
-                async for chunk in response.content.iter_any(): # iter_any() or iter_chunked(chunk_size)
-                    yield chunk
-                logger.info(f"SseClient '{self.server_id}' finished streaming from {download_url}")
-
-        except aiohttp.ClientResponseError as e:
-            logger.error(f"HTTP error during stream download from '{download_url}': {e.status} {e.message}", exc_info=True)
-            # Connection might still be usable for other RPCs, don't necessarily close.
-            raise ConnectionError(f"HTTP error downloading stream: {e.status} {e.message}") from e
-        except aiohttp.ClientConnectorError as e:
-            logger.error(f"Connection error during stream download from '{download_url}': {e}", exc_info=True)
-            await self.close() # Connection likely broken
-            raise ConnectionError(f"Could not connect to download stream at '{download_url}': {e}") from e
-        except asyncio.TimeoutError:
-            logger.warning(f"Timeout downloading stream from '{download_url}'.")
-            # Don't close connection, server might be slow or stream very long with no data.
-            raise TimeoutError(f"Timeout downloading stream from '{download_url}'.")
-        except Exception as e:
-            logger.error(f"Unexpected error downloading stream from '{download_url}': {e}", exc_info=True)
-            if isinstance(e, (aiohttp.ClientError)):
-                 await self.close() # If it's a client lib error, connection might be compromised
-            raise ConnectionError(f"Client-side error downloading stream: {e}") from e

autobyteus/rpc/client/stdio_client_connection.py

@@ -1,280 +0,0 @@
-# file: autobyteus/autobyteus/rpc/client/stdio_client_connection.py
-import asyncio
-import logging
-import json
-from typing import List, Optional, Dict, Any, AsyncIterator # Added Any, AsyncIterator
-
-from autobyteus.rpc.protocol import ProtocolMessage, MessageType, ErrorCode
-from .abstract_client_connection import AbstractClientConnection
-from autobyteus.rpc.config import AgentServerConfig, TransportType # Added TransportType
-
-logger = logging.getLogger(__name__)
-
-DEFAULT_STDIO_TIMEOUT = 10.0  # seconds for a response
-
-class StdioClientConnection(AbstractClientConnection):
-    """
-    Client connection implementation for stdio-based Agent Servers.
-    Manages a subprocess and communicates via its stdin/stdout using
-    newline-delimited JSON ProtocolMessages.
-    """
-
-    def __init__(self, server_config: AgentServerConfig):
-        """
-        Initializes the StdioClientConnection.
-
-        Args:
-            server_config: The configuration for the stdio server.
-
-        Raises:
-            ValueError: If server_config is not for stdio or stdio_command is missing.
-        """
-        if server_config.transport_type != TransportType.STDIO: # Using Enum member
-            raise ValueError("StdioClientConnection requires an AgentServerConfig with transport_type 'stdio'.")
-        if not server_config.stdio_command:
-            raise ValueError("AgentServerConfig for stdio transport must have a stdio_command.")
-
-        super().__init__(server_id=server_config.server_id)
-        self.server_config: AgentServerConfig = server_config
-        self._process: Optional[asyncio.subprocess.Process] = None
-        self._response_futures: Dict[str, asyncio.Future] = {}
-        self._reader_task: Optional[asyncio.Task] = None
-        self._lock = asyncio.Lock() # For managing access to _response_futures
-
-    async def connect(self) -> None:
-        """
-        Starts the stdio server subprocess and establishes communication.
-        """
-        async with self._connection_lock:
-            if self._is_connected:
-                logger.debug(f"StdioClientConnection to '{self.server_id}' already connected.")
-                return
-
-            try:
-                logger.info(f"Connecting StdioClientConnection to '{self.server_id}' using command: {' '.join(self.server_config.stdio_command)}")
-                self._process = await asyncio.create_subprocess_exec(
-                    *self.server_config.stdio_command,
-                    stdin=asyncio.subprocess.PIPE,
-                    stdout=asyncio.subprocess.PIPE,
-                    stderr=asyncio.subprocess.PIPE 
-                )
-                self._is_connected = True
-                self._reader_task = asyncio.create_task(self._read_loop(), name=f"stdio_reader_{self.server_id}")
-                asyncio.create_task(self._log_stderr(), name=f"stdio_stderr_logger_{self.server_id}")
-                logger.info(f"StdioClientConnection to '{self.server_id}' connected successfully (PID: {self._process.pid}).")
-            except Exception as e:
-                logger.error(f"Failed to connect StdioClientConnection to '{self.server_id}': {e}", exc_info=True)
-                self._is_connected = False
-                if self._process and self._process.returncode is None:
-                    self._process.terminate()
-                    await self._process.wait()
-                self._process = None
-                raise ConnectionError(f"Failed to start or connect to stdio server '{self.server_id}': {e}") from e
-
-    async def _log_stderr(self) -> None:
-        """Logs stderr from the subprocess."""
-        if not self._process or not self._process.stderr:
-            return 
-
-        try:
-            while self._process.returncode is None: 
-                line_bytes = await self._process.stderr.readline()
-                if not line_bytes: 
-                    if self._process.returncode is not None: 
-                        break
-                    await asyncio.sleep(0.01) 
-                    continue
-                
-                line_str = line_bytes.decode(errors='replace').strip()
-                if line_str: 
-                    logger.warning(f"StdioServer '{self.server_id}' stderr: {line_str}")
-                
-                if self._process.returncode is not None and self._process.stderr.at_eof():
-                    break
-
-        except asyncio.CancelledError:
-            logger.info(f"Stderr logging for '{self.server_id}' cancelled.")
-        except Exception as e:
-            logger.error(f"Error in stderr logging for '{self.server_id}': {e}", exc_info=True)
-        finally:
-            logger.debug(f"Stderr logging task for '{self.server_id}' finished.")
-
-
-    async def _read_loop(self) -> None:
-        """Reads messages from stdout and dispatches them."""
-        if not self._process or not self._process.stdout:
-            logger.error(f"StdioClientConnection '{self.server_id}' read_loop: Process or stdout not available.")
-            return 
-
-        try:
-            while self._is_connected and self._process.returncode is None:
-                line_bytes = await self._process.stdout.readline()
-                if not line_bytes: 
-                    logger.info(f"StdioServer '{self.server_id}' stdout EOF reached. Process likely terminated.")
-                    if self._is_connected: 
-                        await self._handle_unexpected_disconnect()
-                    break
-                
-                line_str = line_bytes.decode().strip()
-                if not line_str: 
-                    continue
-
-                try:
-                    message = ProtocolMessage.from_json_str(line_str)
-                    if message.id and message.id in self._response_futures:
-                        future = self._response_futures.pop(message.id, None)
-                        if future and not future.done():
-                            future.set_result(message)
-                        elif future and future.done():
-                             logger.warning(f"Future for response ID '{message.id}' was already done. Duplicate response or late arrival?")
-                    elif message.type == MessageType.EVENT:
-                        logger.info(f"Received EVENT message via stdio (unexpected for this model): {message}")
-                    else:
-                        logger.warning(f"Received stdio message with no matching future or unhandled type: {message}")
-                except (json.JSONDecodeError, ValueError) as e: 
-                    logger.error(f"Failed to parse ProtocolMessage from stdio server '{self.server_id}': {e}. Line: '{line_str[:200]}'")
-                except Exception as e:
-                    logger.error(f"Unexpected error processing message from stdio server '{self.server_id}': {e}. Line: '{line_str[:200]}'", exc_info=True)
-
-        except asyncio.CancelledError:
-            logger.info(f"Stdio read_loop for '{self.server_id}' cancelled.")
-        except Exception as e:
-            logger.error(f"Fatal error in stdio read_loop for '{self.server_id}': {e}", exc_info=True)
-            if self._is_connected: 
-                self._handle_unexpected_disconnect()
-        finally:
-            logger.info(f"Stdio read_loop for '{self.server_id}' exiting.")
-            if self._is_connected:
-                await self._handle_unexpected_disconnect(log_warning=False) 
-
-    async def _handle_unexpected_disconnect(self, log_warning=True):
-        """Handles unexpected disconnection by failing pending futures."""
-        if log_warning:
-            logger.warning(f"StdioClientConnection to '{self.server_id}'  unexpectedly disconnected or process terminated.")
-        self._is_connected = False 
-        
-        # Error response is not used here, futures are set with specific errors
-        # error_response = ProtocolMessage.create_error_response(...)
-        async with self._lock:
-            for msg_id, future in list(self._response_futures.items()): 
-                if not future.done():
-                    custom_error = ProtocolMessage.create_error_response(
-                        id=msg_id, code=ErrorCode.INTERNAL_ERROR, 
-                        message=f"Connection lost before response for request ID {msg_id} was received."
-                    )
-                    future.set_result(custom_error) 
-                self._response_futures.pop(msg_id, None)
-
-
-    async def close(self) -> None:
-        """Closes the connection and terminates the subprocess."""
-        async with self._connection_lock:
-            if not self._is_connected and not self._process:
-                logger.debug(f"StdioClientConnection to '{self.server_id}' already closed or never connected.")
-                return
-
-            self._is_connected = False 
-
-            if self._reader_task and not self._reader_task.done():
-                self._reader_task.cancel()
-                try:
-                    await self._reader_task
-                except asyncio.CancelledError:
-                    pass 
-            self._reader_task = None
-            
-            error_on_close = ProtocolMessage.create_error_response(
-                id=None, code=ErrorCode.INTERNAL_ERROR, message="Connection closed by client while request was pending."
-            )
-            for msg_id, future in list(self._response_futures.items()):
-                if not future.done():
-                    custom_error = ProtocolMessage.create_error_response(
-                        id=msg_id, code=ErrorCode.INTERNAL_ERROR,
-                        message=f"Connection closed for request ID {msg_id} before response."
-                    )
-                    future.set_result(custom_error)
-                self._response_futures.pop(msg_id, None)
-
-
-            if self._process:
-                if self._process.returncode is None: 
-                    logger.info(f"Terminating stdio server process for '{self.server_id}' (PID: {self._process.pid}).")
-                    try:
-                        self._process.terminate()
-                        await asyncio.wait_for(self._process.wait(), timeout=DEFAULT_STDIO_TIMEOUT / 2)
-                    except asyncio.TimeoutError:
-                        logger.warning(f"Timeout terminating stdio server '{self.server_id}'. Killing process.")
-                        if self._process.returncode is None: self._process.kill() # Check again before kill
-                        await self._process.wait()
-                    except Exception as e: 
-                        logger.error(f"Error during stdio server termination for '{self.server_id}': {e}")
-                else:
-                    logger.info(f"Stdio server process for '{self.server_id}' (PID: {self._process.pid}) already exited with code {self._process.returncode}.")
-                self._process = None
-            
-            logger.info(f"StdioClientConnection to '{self.server_id}' closed.")
-
-    async def send_request(self, request_message: ProtocolMessage) -> ProtocolMessage:
-        """Sends a request and waits for a response."""
-        if not self._is_connected or not self._process or not self._process.stdin:
-            # Attempt to reconnect if not connected
-            logger.info(f"StdioClientConnection '{self.server_id}' not connected. Attempting to connect before send_request.")
-            await self.connect()
-            if not self._is_connected or not self._process or not self._process.stdin:
-                raise ConnectionError(f"Failed to connect to stdio server '{self.server_id}' for send_request.")
-
-        if request_message.type != MessageType.REQUEST:
-            raise ValueError("ProtocolMessage must be of type REQUEST to be sent via send_request.")
-        if not request_message.id: 
-            raise ValueError("Request ProtocolMessage must have an ID.")
-
-        future: asyncio.Future[ProtocolMessage] = asyncio.Future()
-        async with self._lock:
-            self._response_futures[request_message.id] = future
-
-        try:
-            json_str = request_message.to_json_str()
-            logger.debug(f"StdioClient '{self.server_id}' sending: {json_str}")
-            self._process.stdin.write(json_str.encode() + b'\n')
-            await self._process.stdin.drain()
-        except Exception as e:
-            async with self._lock:
-                self._response_futures.pop(request_message.id, None) 
-            # Don't cancel future, let it timeout or be resolved by _handle_unexpected_disconnect
-            logger.error(f"Error sending request to stdio server '{self.server_id}': {e}", exc_info=True)
-            # If send fails, connection is likely broken. Mark as such and try to close.
-            await self.close()
-            raise ConnectionError(f"Failed to send request to stdio server '{self.server_id}': {e}") from e
-
-        try:
-            response = await asyncio.wait_for(future, timeout=DEFAULT_STDIO_TIMEOUT)
-            return response
-        except asyncio.TimeoutError:
-            logger.warning(f"Timeout waiting for response to request ID '{request_message.id}' from stdio server '{self.server_id}'.")
-            async with self._lock:
-                if request_message.id in self._response_futures:
-                    self._response_futures.pop(request_message.id, None)
-            return ProtocolMessage.create_error_response(
-                id=request_message.id,
-                code=ErrorCode.SERVER_ERROR_TIMEOUT,
-                message=f"Timeout waiting for response to request ID '{request_message.id}'."
-            )
-        except asyncio.CancelledError: 
-            logger.info(f"Request ID '{request_message.id}' was cancelled while awaiting response.")
-            return ProtocolMessage.create_error_response(
-                id=request_message.id,
-                code=ErrorCode.INTERNAL_ERROR,
-                message=f"Request ID '{request_message.id}' cancelled."
-            )
-
-    async def request_and_download_stream(
-        self, 
-        stream_request_params: Dict[str, Any],
-        target_agent_id: str
-    ) -> AsyncIterator[bytes]:
-        logger.warning(f"StdioClientConnection does not support HTTP stream downloads for target_agent_id '{target_agent_id}'.")
-        raise NotImplementedError("StdioClientConnection does not support HTTP stream downloads.")
-        # This construct makes it an async generator that immediately raises
-        if False: # pragma: no cover
-            yield b''
-

autobyteus/rpc/config/__init__.py

@@ -1,13 +0,0 @@
-# file: autobyteus/autobyteus/rpc/config/__init__.py
-"""
-Configuration components for the AutoByteUs RPC framework.
-"""
-from .agent_server_config import AgentServerConfig
-from .agent_server_registry import AgentServerRegistry, default_agent_server_registry
-
-__all__ = [
-    "AgentServerConfig",
-    "AgentServerRegistry",
-    "default_agent_server_registry",
-]
-