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

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",
-]
-

autobyteus/rpc/config/agent_server_config.py

@@ -1,153 +0,0 @@
-# file: autobyteus/autobyteus/rpc/config/agent_server_config.py
-import logging
-from typing import Optional, Dict, Any, List # List was missing
-from pydantic import BaseModel, Field, validator, HttpUrl
-
-from autobyteus.rpc.transport_type import TransportType
-
-logger = logging.getLogger(__name__)
-
-class AgentServerConfig(BaseModel):
-    """
-    Configuration for an Agent Server, specifying how it can be connected to.
-    """
-    server_id: str = Field(..., description="Unique identifier for this server configuration.")
-    transport_type: TransportType = Field(..., description="The transport mechanism (e.g., stdio, sse).")
-    
-    # For stdio transport
-    stdio_command: Optional[List[str]] = Field(default=None, description="Command and arguments to launch the agent server process for stdio.")
-    
-    # For sse transport
-    sse_base_url: Optional[HttpUrl] = Field(default=None, description="Base URL for the agent server's HTTP/SSE endpoints.")
-    sse_request_endpoint: str = Field(default="/invoke", description="Relative path for synchronous requests (e.g., invoke_method).")
-    sse_events_endpoint: str = Field(default="/events", description="Relative path for the Server-Sent Events stream.")
-    # New field for HTTP stream downloads
-    sse_stream_download_path_prefix: str = Field(default="/streams", description="Base relative path for HTTP stream downloads. Full path will be {base_url}{prefix}/{agent_id_on_server}/{stream_id}.")
-
-
-    # Optional metadata
-    metadata: Dict[str, Any] = Field(default_factory=dict, description="Optional metadata for the server configuration.")
-
-    class Config:
-        use_enum_values = True # Serialize enums to their values
-        validate_assignment = True
-
-    @validator('stdio_command')
-    def _check_stdio_command(cls, v, values):
-        if values.get('transport_type') == TransportType.STDIO and not v:
-            raise ValueError("stdio_command is required for stdio transport type.")
-        if values.get('transport_type') != TransportType.STDIO and v:
-            logger.warning("stdio_command is provided but transport_type is not stdio. It will be ignored.")
-        return v
-
-    @validator('sse_base_url')
-    def _check_sse_base_url(cls, v, values):
-        if values.get('transport_type') == TransportType.SSE and not v:
-            raise ValueError("sse_base_url is required for sse transport type.")
-        if values.get('transport_type') != TransportType.SSE and v:
-            logger.warning("sse_base_url is provided but transport_type is not sse. It will be ignored.")
-        return v
-    
-    @validator('sse_stream_download_path_prefix')
-    def _check_sse_stream_download_path_prefix(cls, v, values):
-        if not v.startswith('/'):
-            raise ValueError("sse_stream_download_path_prefix must start with a '/'.")
-        if values.get('transport_type') != TransportType.SSE and v != "/streams": # if not default and not SSE
-             logger.warning("sse_stream_download_path_prefix is customized but transport_type is not sse. It might be ignored.")
-        return v
-
-
-    def get_sse_full_request_url(self) -> Optional[str]:
-        """Returns the full URL for SSE synchronous requests if applicable."""
-        if self.transport_type == TransportType.SSE and self.sse_base_url:
-            # Pydantic's HttpUrl converts to string automatically when concatenated this way
-            return str(self.sse_base_url).rstrip('/') + self.sse_request_endpoint
-        return None
-
-    def get_sse_full_events_url(self) -> Optional[str]:
-        """Returns the full URL for the SSE event stream if applicable."""
-        if self.transport_type == TransportType.SSE and self.sse_base_url:
-            return str(self.sse_base_url).rstrip('/') + self.sse_events_endpoint
-        return None
-
-    def get_sse_full_stream_download_url_prefix_for_agent(self, agent_id_on_server: str) -> Optional[str]:
-        """
-        Returns the full URL prefix for HTTP stream downloads for a specific agent,
-        up to the point where stream_id should be appended.
-        e.g., http://host:port/streams/{agent_id_on_server}
-        """
-        if self.transport_type == TransportType.SSE and self.sse_base_url:
-            base = str(self.sse_base_url).rstrip('/')
-            prefix = self.sse_stream_download_path_prefix.rstrip('/')
-            return f"{base}{prefix}/{agent_id_on_server}"
-        return None
-
-
-    def __repr__(self) -> str:
-        return f"<AgentServerConfig server_id='{self.server_id}', transport='{self.transport_type.value}'>"
-
-if __name__ == "__main__": # pragma: no cover
-    logging.basicConfig(level=logging.DEBUG)
-
-    # Stdio Example
-    try:
-        stdio_config_data = {
-            "server_id": "local_agent_stdio",
-            "transport_type": "stdio",
-            "stdio_command": ["python", "-m", "autobyteus.agent.server_main", "--config-id", "local_agent_stdio"]
-        }
-        stdio_config = AgentServerConfig(**stdio_config_data)
-        logger.info(f"Stdio Config: {stdio_config!r}")
-        logger.info(f"Stdio Config (dict): {stdio_config.model_dump_json(indent=2)}")
-    except ValueError as e:
-        logger.error(f"Error creating stdio_config: {e}")
-
-    # SSE Example
-    try:
-        sse_config_data = {
-            "server_id": "remote_agent_sse",
-            "transport_type": "sse",
-            "sse_base_url": "http://localhost:8000/agent1",
-            "sse_request_endpoint": "/api/request",
-            "sse_events_endpoint": "/api/events",
-            "sse_stream_download_path_prefix": "/downloadable_content" # Custom prefix
-        }
-        sse_config = AgentServerConfig(**sse_config_data)
-        logger.info(f"SSE Config: {sse_config!r}")
-        logger.info(f"SSE Config (dict): {sse_config.model_dump_json(indent=2)}")
-        logger.info(f"SSE Request URL: {sse_config.get_sse_full_request_url()}")
-        logger.info(f"SSE Events URL: {sse_config.get_sse_full_events_url()}")
-        logger.info(f"SSE Stream Download URL prefix for agent 'test_agent': {sse_config.get_sse_full_stream_download_url_prefix_for_agent('test_agent')}")
-        
-        # Test HttpUrl string conversion
-        assert isinstance(sse_config.sse_base_url, HttpUrl)
-        logger.info(f"SSE base URL type: {type(sse_config.sse_base_url)}, value: {sse_config.sse_base_url}")
-
-    except ValueError as e:
-        logger.error(f"Error creating sse_config: {e}")
-
-    # Validation error examples
-    try:
-        invalid_stdio_data = {"server_id": "invalid_stdio", "transport_type": "stdio"} # Missing stdio_command
-        AgentServerConfig(**invalid_stdio_data)
-    except ValueError as e:
-        logger.error(f"Expected validation error (stdio): {e}")
-
-    try:
-        invalid_sse_data = {"server_id": "invalid_sse", "transport_type": "sse"} # Missing sse_base_url
-        AgentServerConfig(**invalid_sse_data)
-    except ValueError as e:
-        logger.error(f"Expected validation error (sse): {e}")
-        
-    try:
-        invalid_url_sse_data = {"server_id": "invalid_url_sse", "transport_type": "sse", "sse_base_url": "not_a_url"}
-        AgentServerConfig(**invalid_url_sse_data)
-    except ValueError as e:
-        logger.error(f"Expected validation error (invalid sse_base_url): {e}")
-    
-    try:
-        invalid_stream_prefix = {"server_id": "invalid_stream_prefix", "transport_type": "sse", "sse_base_url":"http://foo.com", "sse_stream_download_path_prefix": "no_slash_prefix"}
-        AgentServerConfig(**invalid_stream_prefix)
-    except ValueError as e:
-        logger.error(f"Expected validation error (invalid sse_stream_download_path_prefix): {e}")
-

autobyteus/rpc/config/agent_server_registry.py

@@ -1,152 +0,0 @@
-# file: autobyteus/autobyteus/rpc/config/agent_server_registry.py
-import logging
-from typing import Dict, Optional, List
-
-from autobyteus.utils.singleton import SingletonMeta
-from .agent_server_config import AgentServerConfig
-
-logger = logging.getLogger(__name__)
-
-class AgentServerRegistry(metaclass=SingletonMeta):
-    """
-    A singleton registry for storing and managing AgentServerConfig objects.
-    This allows different parts of the system to retrieve server connection
-    details by a server_id.
-    """
-
-    def __init__(self):
-        """Initializes the AgentServerRegistry with an empty store."""
-        self._configs: Dict[str, AgentServerConfig] = {}
-        logger.info("AgentServerRegistry initialized.")
-
-    def register_config(self, config: AgentServerConfig) -> None:
-        """
-        Registers an agent server configuration.
-        If a configuration with the same server_id already exists, it will be
-        overwritten, and a warning will be logged.
-
-        Args:
-            config: The AgentServerConfig object to register.
-
-        Raises:
-            TypeError: If the provided config is not an AgentServerConfig instance.
-        """
-        if not isinstance(config, AgentServerConfig):
-            raise TypeError(f"Expected AgentServerConfig instance, got {type(config).__name__}.")
-
-        if config.server_id in self._configs:
-            logger.warning(f"Overwriting existing agent server configuration for server_id: '{config.server_id}'.")
-        
-        self._configs[config.server_id] = config
-        logger.info(f"AgentServerConfig for server_id '{config.server_id}' (transport: {config.transport_type.value}) registered.")
-
-    def get_config(self, server_id: str) -> Optional[AgentServerConfig]:
-        """
-        Retrieves an agent server configuration by its server_id.
-
-        Args:
-            server_id: The unique identifier of the server configuration.
-
-        Returns:
-            The AgentServerConfig object if found, otherwise None.
-        """
-        if not isinstance(server_id, str):
-            logger.warning(f"Attempted to retrieve agent server config with non-string server_id: {type(server_id).__name__}.")
-            return None
-        
-        config = self._configs.get(server_id)
-        if not config:
-            logger.debug(f"AgentServerConfig with server_id '{server_id}' not found in registry.")
-        return config
-
-    def unregister_config(self, server_id: str) -> bool:
-        """
-        Removes an agent server configuration from the registry.
-
-        Args:
-            server_id: The server_id of the configuration to remove.
-
-        Returns:
-            True if the configuration was found and removed, False otherwise.
-        """
-        if not isinstance(server_id, str):
-            logger.warning(f"Attempted to unregister agent server config with non-string server_id: {type(server_id).__name__}.")
-            return False
-
-        if server_id in self._configs:
-            removed_config = self._configs.pop(server_id)
-            logger.info(f"AgentServerConfig for server_id '{removed_config.server_id}' unregistered successfully.")
-            return True
-        else:
-            logger.warning(f"AgentServerConfig with server_id '{server_id}' not found for unregistration.")
-            return False
-
-    def list_server_ids(self) -> List[str]:
-        """Returns a list of all registered server_ids."""
-        return list(self._configs.keys())
-
-    def get_all_configs(self) -> Dict[str, AgentServerConfig]:
-        """Returns a shallow copy of all registered configurations."""
-        return dict(self._configs)
-
-    def clear(self) -> None:
-        """Removes all configurations from the registry."""
-        count = len(self._configs)
-        self._configs.clear()
-        logger.info(f"Cleared {count} configurations from the AgentServerRegistry.")
-
-    def __len__(self) -> int:
-        return len(self._configs)
-
-    def __contains__(self, server_id: str) -> bool:
-        if isinstance(server_id, str):
-            return server_id in self._configs
-        return False
-
-# Default global instance of the registry
-default_agent_server_registry = AgentServerRegistry()
-
-if __name__ == "__main__": # pragma: no cover
-    logging.basicConfig(level=logging.DEBUG)
-
-    registry = default_agent_server_registry # Use the default instance
-
-    # Stdio Config
-    stdio_config_data = {
-        "server_id": "local_agent_stdio_main",
-        "transport_type": "stdio",
-        "stdio_command": ["python", "-m", "some_module"]
-    }
-    stdio_conf = AgentServerConfig(**stdio_config_data)
-    registry.register_config(stdio_conf)
-
-    # SSE Config
-    sse_config_data = {
-        "server_id": "remote_agent_sse_main",
-        "transport_type": "sse",
-        "sse_base_url": "http://localhost:8080"
-    }
-    sse_conf = AgentServerConfig(**sse_config_data)
-    registry.register_config(sse_conf)
-
-    logger.info(f"Registered server IDs: {registry.list_server_ids()}")
-    
-    retrieved_stdio = registry.get_config("local_agent_stdio_main")
-    if retrieved_stdio:
-        logger.info(f"Retrieved Stdio Config: {retrieved_stdio.stdio_command}")
-    
-    retrieved_sse = registry.get_config("remote_agent_sse_main")
-    if retrieved_sse:
-        logger.info(f"Retrieved SSE Config URL: {retrieved_sse.get_sse_full_request_url()}")
-
-    assert "local_agent_stdio_main" in registry
-    assert len(registry) == 2
-
-    registry.unregister_config("local_agent_stdio_main")
-    assert "local_agent_stdio_main" not in registry
-    logger.info(f"After unregistering, server IDs: {registry.list_server_ids()}")
-
-    registry.clear()
-    assert len(registry) == 0
-    logger.info(f"After clearing, server IDs: {registry.list_server_ids()}")
-