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

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()}")
-

autobyteus/rpc/hosting.py

@@ -1,244 +0,0 @@
-# file: autobyteus/autobyteus/rpc/hosting.py
-import asyncio
-import logging
-import signal
-from typing import Optional, Dict, Union # Added Dict, Union
-
-from autobyteus.agent.agent import Agent
-from autobyteus.rpc.server import AgentServerEndpoint
-from autobyteus.rpc.config import AgentServerConfig
-from autobyteus.rpc.transport_type import TransportType
-
-logger = logging.getLogger(__name__)
-
-async def serve_agent_stdio(
-    agent: Agent,
-    stop_event: asyncio.Event,
-    server_id_for_config: Optional[str] = None
-) -> None:
-    """
-    Hosts a single Agent instance over STDIO within the current process.
-    This function will run until the stop_event is set.
-    The script calling this function will dedicate its sys.stdin/sys.stdout
-    to RPC communication.
-
-    Args:
-        agent: The Agent instance to serve.
-        stop_event: An asyncio.Event that signals when to stop the server.
-        server_id_for_config: Optional string to use as server_id in the internal
-                              AgentServerConfig. Defaults to f"embedded_stdio_{agent.agent_id}".
-    """
-    if not isinstance(agent, Agent):
-        raise TypeError("agent must be an instance of autobyteus.agent.agent.Agent")
-    if not isinstance(stop_event, asyncio.Event):
-        raise TypeError("stop_event must be an asyncio.Event")
-
-    actual_server_id = server_id_for_config or f"embedded_stdio_{agent.agent_id}"
-    
-    stdio_config = AgentServerConfig(
-        server_id=actual_server_id,
-        transport_type=TransportType.STDIO,
-        stdio_command=["in-process-stdio-server"] 
-    )
-    logger.info(f"Configuring in-process STDIO server for agent '{agent.agent_id}' with config_id '{actual_server_id}'.")
-
-    server_endpoint = AgentServerEndpoint(agent) # Pass single agent
-
-    try:
-        if not agent.is_running:
-            logger.info(f"Starting agent '{agent.agent_id}' for STDIO hosting...")
-            agent.start() 
-
-        logger.info(f"Starting STDIO server endpoint for agent '{agent.agent_id}'...")
-        await server_endpoint.start(stdio_config)
-        
-        logger.info(f"Agent '{agent.agent_id}' now being served via STDIO. Waiting for stop signal...")
-        await stop_event.wait()
-        logger.info(f"Stop signal received for STDIO server of agent '{agent.agent_id}'.")
-
-    except Exception as e:
-        logger.error(f"Error during STDIO hosting for agent '{agent.agent_id}': {e}", exc_info=True)
-    finally:
-        logger.info(f"Shutting down STDIO server for agent '{agent.agent_id}'...")
-        if server_endpoint.is_running:
-            await server_endpoint.stop()
-        
-        if agent.is_running: 
-            logger.info(f"Stopping agent '{agent.agent_id}' after STDIO hosting...")
-            await agent.stop()
-        logger.info(f"STDIO hosting for agent '{agent.agent_id}' has shut down.")
-
-
-async def serve_single_agent_http_sse(
-    agent: Agent,
-    host: str,
-    port: int,
-    stop_event: asyncio.Event,
-    server_id_prefix: str = "embedded_http_single",
-    request_endpoint: str = "/rpc",
-    events_endpoint_base: str = "/events" # Base path for events
-) -> None:
-    """
-    Hosts a single Agent instance over HTTP/SSE within the current process.
-    The agent will be accessible using its own agent_id as the key on the server
-    (e.g., for SSE events: /events/{agent.agent_id}).
-
-    Args:
-        agent: The Agent instance to serve.
-        host: The hostname or IP address to bind the HTTP server to.
-        port: The port number to bind the HTTP server to.
-        stop_event: An asyncio.Event that signals when to stop the server.
-        server_id_prefix: Prefix for the server_id in the internal AgentServerConfig.
-        request_endpoint: The URL path for RPC requests.
-        events_endpoint_base: The base URL path for SSE event streams (agent_id will be appended).
-    """
-    # This function now essentially calls serve_multiple_agents_http_sse
-    # The agent's own ID will be used as the key for routing on the server.
-    agents_to_serve = {agent.agent_id: agent}
-    await serve_multiple_agents_http_sse(
-        agents=agents_to_serve,
-        host=host,
-        port=port,
-        stop_event=stop_event,
-        server_id_prefix=server_id_prefix,
-        request_endpoint=request_endpoint,
-        events_endpoint_base=events_endpoint_base
-    )
-
-
-async def serve_multiple_agents_http_sse(
-    agents: Dict[str, Agent], # Key: server-routable ID, Value: Agent instance
-    host: str,
-    port: int,
-    stop_event: asyncio.Event,
-    server_id_prefix: str = "embedded_http_multi",
-    request_endpoint: str = "/rpc", # Single RPC endpoint for the gateway
-    events_endpoint_base: str = "/events" # Base for /events/{agent_id_on_server}
-) -> None:
-    """
-    Hosts multiple Agent instances over a single HTTP/SSE server within the current process.
-    This function will run until the stop_event is set.
-
-    Args:
-        agents: A dictionary where keys are server-routable string IDs for each agent,
-                and values are the Agent instances to serve.
-        host: The hostname or IP address to bind the HTTP server to.
-        port: The port number to bind the HTTP server to.
-        stop_event: An asyncio.Event that signals when to stop the server.
-        server_id_prefix: Prefix for the server_id in the internal AgentServerConfig for the gateway.
-        request_endpoint: The URL path for all RPC requests (target_agent_id must be in payload).
-        events_endpoint_base: The base URL path for SSE event streams. Clients subscribe to
-                              {events_endpoint_base}/{server_routable_agent_id}.
-    """
-    if not isinstance(agents, dict) or not agents:
-        raise TypeError("agents must be a non-empty dictionary of [str, Agent] instances.")
-    if not all(isinstance(k, str) and isinstance(v, Agent) for k, v in agents.items()):
-        raise TypeError("agents dictionary keys must be strings and values must be Agent instances.")
-    if not isinstance(stop_event, asyncio.Event):
-        raise TypeError("stop_event must be an asyncio.Event")
-
-    # server_id for the gateway server config
-    gateway_server_id = f"{server_id_prefix}_gateway" 
-    
-    sse_config = AgentServerConfig(
-        server_id=gateway_server_id,
-        transport_type=TransportType.SSE,
-        sse_base_url=f"http://{host}:{port}", # type: ignore
-        sse_request_endpoint=request_endpoint,
-        sse_events_endpoint=events_endpoint_base # SseServerHandler will append /{agent_id_on_server}
-    )
-    routable_agent_ids = list(agents.keys())
-    logger.info(f"Configuring in-process HTTP/SSE gateway server at {sse_config.sse_base_url} "
-                f"(config_id: '{gateway_server_id}') to serve agents: {routable_agent_ids}.")
-
-    server_endpoint = AgentServerEndpoint(agents) # Pass the dictionary of agents
-
-    try:
-        for agent_id_on_server, agent_instance in agents.items():
-            if not agent_instance.is_running:
-                logger.info(f"Starting agent '{agent_instance.agent_id}' (server key: '{agent_id_on_server}') for HTTP/SSE gateway hosting...")
-                agent_instance.start()
-
-        logger.info(f"Starting HTTP/SSE gateway server endpoint for agents: {routable_agent_ids}...")
-        await server_endpoint.start(sse_config)
-        
-        logger.info(f"Multi-agent gateway now being served via HTTP/SSE on http://{host}:{port}. Waiting for stop signal...")
-        await stop_event.wait()
-        logger.info(f"Stop signal received for multi-agent HTTP/SSE gateway server.")
-
-    except Exception as e:
-        logger.error(f"Error during multi-agent HTTP/SSE hosting: {e}", exc_info=True)
-    finally:
-        logger.info(f"Shutting down multi-agent HTTP/SSE gateway server...")
-        if server_endpoint.is_running:
-            await server_endpoint.stop()
-        
-        for agent_id_on_server, agent_instance in agents.items():
-            if agent_instance.is_running:
-                logger.info(f"Stopping agent '{agent_instance.agent_id}' (server key: '{agent_id_on_server}')...")
-                await agent_instance.stop()
-        logger.info(f"Multi-agent HTTP/SSE hosting has shut down.")
-
-
-# Renamed old serve_agent_http_sse to serve_single_agent_http_sse
-# Kept the old signature for backward compatibility if any tests used it,
-# but it now delegates to the multi-agent version.
-async def serve_agent_http_sse(
-    agent: Agent,
-    host: str,
-    port: int,
-    stop_event: asyncio.Event,
-    server_id_prefix: str = "embedded_http", # Note: prefix change if desired
-    request_endpoint: str = "/rpc",
-    events_endpoint_base: str = "/events" 
-) -> None:
-     await serve_single_agent_http_sse(
-         agent, host, port, stop_event, server_id_prefix, request_endpoint, events_endpoint_base
-     )
-
-
-if __name__ == "__main__": # pragma: no cover
-    logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
-    from autobyteus.agent.registry.agent_definition import AgentDefinition
-    from autobyteus.agent.registry.agent_registry import default_agent_registry, default_definition_registry
-    from autobyteus.llm.models import LLMModel
-    try: import autobyteus.agent.input_processor 
-    except ImportError: print("Warning: input_processor module not found.", file=sys.stderr)
-
-    def create_example_agent(name: str, role: str) -> Optional[Agent]:
-        agent_def = default_definition_registry.get(name, role)
-        if not agent_def:
-            try:
-                agent_def = AgentDefinition(name=name, role=role, description=f"{name} agent",
-                                            system_prompt=f"You are {name}.", tool_names=[],
-                                            input_processor_names=["PassthroughInputProcessor"])
-            except Exception as e_def:
-                logger.error(f"Failed to create def for {name}: {e_def}"); return None
-        
-        try: chosen_llm_model = next(iter(LLMModel)) if LLMModel else None
-        except StopIteration: chosen_llm_model = None
-        if not chosen_llm_model:
-            class MockLLMModel(str, Enum): DUMMY = "dummy_model" # type: ignore
-            LLMModel = MockLLMModel # type: ignore
-            chosen_llm_model = LLMModel.DUMMY
-        
-        if chosen_llm_model:
-            try: return default_agent_registry.create_agent(definition=agent_def, llm_model=chosen_llm_model)
-            except Exception as e_create: logger.error(f"Failed to create agent {name}: {e_create}", exc_info=True)
-        return None
-
-    agent1 = create_example_agent("AgentAlpha", "analyzer")
-    agent2 = create_example_agent("AgentBeta", "writer")
-
-    if agent1 and agent2:
-        agents_for_server = {
-            "alpha": agent1, # Routable ID "alpha" maps to AgentAlpha
-            "beta": agent2   # Routable ID "beta" maps to AgentBeta
-        }
-        # Example: Run the multi-agent SSE server
-        asyncio.run(serve_multiple_agents_http_sse(agents_for_server, "127.0.0.1", 8888, asyncio.Event()))
-        # To test, connect to http://127.0.0.1:8888/events/alpha and /events/beta for SSE
-        # Send POST to http://127.0.0.1:8888/rpc with {"target_agent_id": "alpha", ...}
-    else:
-        logger.error("Could not create example agents for multi-agent hosting demo.")
-