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

autobyteus/rpc/server/sse_server_handler.py

@@ -1,182 +0,0 @@
-    # file: autobyteus/autobyteus/rpc/server/sse_server_handler.py
-    import asyncio
-    import logging
-    import json
-    from typing import Dict, Optional, Union, Set, cast, AsyncIterator 
-    from weakref import WeakSet
-    
-    from aiohttp import web 
-    from aiohttp_sse import sse_response 
-    
-    from autobyteus.agent.agent import Agent
-    # MODIFIED: Import AgentEventStream (remains the same, but it's now the sole class)
-    from autobyteus.agent.streaming import AgentEventStream 
-    from autobyteus.agent.streaming.stream_events import StreamEvent, StreamEventType 
-    from autobyteus.rpc.protocol import ProtocolMessage, MessageType, ErrorCode, RequestType, ResponseType, EventType as RPCEventType 
-    from autobyteus.rpc.server.base_method_handler import BaseMethodHandler
-    from autobyteus.rpc.config import AgentServerConfig 
-    
-    logger = logging.getLogger(__name__)
-    
-    DEFAULT_STREAM_CHUNK_SIZE = 8192 
-    
-    class SseServerHandler:
-        def __init__(self, agents: Dict[str, Agent], method_handlers: Dict[Union[RequestType, str], BaseMethodHandler]):
-            self._agents: Dict[str, Agent] = agents
-            self._method_handlers = method_handlers
-            self._app = web.Application()
-            self._runner: Optional[web.AppRunner] = None
-            self._site: Optional[web.TCPSite] = None
-            self._active_sse_forwarding_tasks: Dict[web.StreamResponse, asyncio.Task] = {}
-            logger.info(f"SseServerHandler initialized to serve agents: {list(self._agents.keys())}.")
-    
-        def _setup_routes(self, config: AgentServerConfig):
-            # ... (method body remains the same) ...
-            rpc_request_path = config.sse_request_endpoint
-            base_events_path = config.sse_events_endpoint.rstrip('/')
-            full_events_path = f"{base_events_path}/{{agent_id_on_server}}"
-            stream_download_prefix = config.sse_stream_download_path_prefix.rstrip('/')
-            full_stream_download_path = f"{stream_download_prefix}/{{agent_id_on_server}}/{{stream_id}}"
-            self._app.router.add_post(rpc_request_path, self.handle_rpc_request)
-            self._app.router.add_get(full_events_path, self.handle_sse_events_subscription)
-            self._app.router.add_get(full_stream_download_path, self.handle_http_stream_download)
-            logger.info(f"SseServerHandler routes: POST {rpc_request_path} (RPC), GET {full_events_path} (SSE per agent), GET {full_stream_download_path} (HTTP Stream Download).")
-
-        async def handle_rpc_request(self, http_request: web.Request) -> web.Response:
-            # ... (method body remains the same) ...
-            request_id: Optional[str] = None; raw_body_str: str = ""; target_agent_id: Optional[str] = None
-            try:
-                raw_body = await http_request.read(); raw_body_str = raw_body.decode()
-                try: parsed_json_early = json.loads(raw_body_str); request_id = parsed_json_early.get("id")
-                except json.JSONDecodeError: pass
-                request_message = ProtocolMessage.from_json_str(raw_body_str); request_id = request_message.id 
-                if request_message.type != MessageType.REQUEST or not request_message.method:
-                    return self._create_json_error_response(request_id, ErrorCode.INVALID_REQUEST, "Must be REQUEST with method.", 400)
-                if request_message.params and "target_agent_id" in request_message.params:
-                    target_agent_id = str(request_message.params["target_agent_id"])
-                if not target_agent_id: return self._create_json_error_response(request_id, ErrorCode.INVALID_PARAMS, "'target_agent_id' missing in request params.", 400)
-                target_agent = self._agents.get(target_agent_id)
-                if not target_agent: return self._create_json_error_response(request_id, ErrorCode.METHOD_NOT_FOUND, f"Agent with id '{target_agent_id}' not found.", 404)
-                actual_handler_params = request_message.params
-                handler = self._method_handlers.get(request_message.method)
-                if not handler: return self._create_json_error_response(request_id, ErrorCode.METHOD_NOT_FOUND, f"RPC Method '{request_message.method}' not found.", 404)
-                logger.debug(f"SseServerHandler dispatching RPC '{request_message.method}' (ReqID: {request_id}) to '{handler.__class__.__name__}' for agent '{target_agent_id}'.")
-                response_proto = await handler.handle(request_id, actual_handler_params, target_agent) 
-                if response_proto.response_type == ResponseType.STREAM_DOWNLOAD_READY and response_proto.result and "stream_id" in response_proto.result and target_agent_id: 
-                    server_config: AgentServerConfig = http_request.app['agent_server_config']
-                    full_url_prefix = server_config.get_sse_full_stream_download_url_prefix_for_agent(target_agent_id)
-                    if full_url_prefix:
-                        stream_id = response_proto.result["stream_id"]; download_url = f"{full_url_prefix.rstrip('/')}/{stream_id}"
-                        response_proto.result["download_url"] = download_url; logger.info(f"Constructed download URL for stream_id '{stream_id}': {download_url}")
-                    else: logger.error(f"Could not construct download_url for stream_id '{response_proto.result['stream_id']}'.")
-                http_status = 200
-                if response_proto.type == MessageType.ERROR and response_proto.error:
-                    if response_proto.error.code == ErrorCode.METHOD_NOT_FOUND.value: http_status = 404
-                    elif response_proto.error.code in [ErrorCode.INVALID_REQUEST.value, ErrorCode.INVALID_PARAMS.value, ErrorCode.PARSE_ERROR.value]: http_status = 400
-                    else: http_status = 500
-                return web.json_response(response_proto.model_dump(exclude_none=True), status=http_status)
-            except json.JSONDecodeError as e: logger.error(f"Sse JSONDecodeError: {e}. Body: '{raw_body_str[:200]}'"); return self._create_json_error_response(request_id, ErrorCode.PARSE_ERROR, f"JSON parse error: {e}", 400)
-            except ValueError as e: logger.error(f"Sse Protocol validation error: {e}. Body: '{raw_body_str[:200]}'"); return self._create_json_error_response(request_id, ErrorCode.INVALID_REQUEST, f"Invalid request: {e}", 400)
-            except Exception as e: logger.error(f"Sse unexpected error: {e}", exc_info=True); return self._create_json_error_response(request_id, ErrorCode.INTERNAL_ERROR, f"Server error: {e}", 500)
-
-        def _create_json_error_response(self, req_id: Optional[str], code: ErrorCode, msg: str, http_status: int) -> web.Response:
-            # ... (method body remains the same) ...
-            err_proto = ProtocolMessage.create_error_response(req_id, code, msg)
-            return web.json_response(err_proto.model_dump(exclude_none=True), status=http_status)
-    
-        async def handle_sse_events_subscription(self, http_request: web.Request) -> web.StreamResponse:
-            # ... (method body remains the same, it instantiates AgentEventStream and calls all_events()) ...
-            agent_id_on_server = http_request.match_info.get("agent_id_on_server")
-            if not agent_id_on_server: raise web.HTTPBadRequest(text="'agent_id_on_server' path param required.")
-            target_agent = self._agents.get(agent_id_on_server)
-            if not target_agent: raise web.HTTPNotFound(text=f"Agent '{agent_id_on_server}' not found.")
-            client_addr = http_request.remote
-            logger.info(f"SSE client {client_addr} subscribing to events for agent '{target_agent.agent_id}' (server key: '{agent_id_on_server}').")
-            sse_resp = web.StreamResponse(status=200, reason='OK', headers={'Content-Type': 'text/event-stream', 'Cache-Control': 'no-cache', 'Connection': 'keep-alive'})
-            await sse_resp.prepare(http_request) 
-            forwarding_task = asyncio.create_task(self._stream_agent_events_to_client(sse_resp, target_agent, agent_id_on_server), name=f"sse_fwd_{target_agent.agent_id}_{client_addr}")
-            self._active_sse_forwarding_tasks[sse_resp] = forwarding_task
-            try: await forwarding_task 
-            except asyncio.CancelledError: logger.info(f"SSE task for agent '{target_agent.agent_id}' to {client_addr} cancelled.")
-            except Exception as e: logger.error(f"Error in SSE streaming for agent '{target_agent.agent_id}' to {client_addr}: {e}", exc_info=True)
-            finally: logger.info(f"SSE client {client_addr} for agent '{target_agent.agent_id}' disconnected."); self._active_sse_forwarding_tasks.pop(sse_resp, None)
-            return sse_resp
-
-        async def _stream_agent_events_to_client(self, sse_client_resp: web.StreamResponse, agent: Agent, agent_id_on_server: str):
-            # Instantiates AgentEventStream
-            event_stream_provider = AgentEventStream(agent)
-            logger.debug(f"SseServerHandler: Streaming events from agent '{agent.agent_id}' (key: {agent_id_on_server}) via AgentEventStream.all_events().")
-            try:
-                # Calls .all_events() method
-                async for agent_event_obj in event_stream_provider.all_events(): 
-                    if sse_client_resp.closed: break
-                    rpc_event_type: RPCEventType
-                    if agent_event_obj.event_type == StreamEventType.ASSISTANT_CHUNK: rpc_event_type = RPCEventType.AGENT_OUTPUT_CHUNK
-                    elif agent_event_obj.event_type == StreamEventType.ASSISTANT_FINAL_MESSAGE: rpc_event_type = RPCEventType.AGENT_FINAL_MESSAGE
-                    elif agent_event_obj.event_type == StreamEventType.TOOL_INTERACTION_LOG_ENTRY: rpc_event_type = RPCEventType.TOOL_LOG_ENTRY
-                    elif agent_event_obj.event_type == StreamEventType.AGENT_STATUS_CHANGE: rpc_event_type = RPCEventType.AGENT_STATUS_UPDATE
-                    elif agent_event_obj.event_type == StreamEventType.ERROR_EVENT: rpc_event_type = RPCEventType.AGENT_STATUS_UPDATE; logger.error(f"Unified stream error for agent '{agent.agent_id}': {agent_event_obj.data}")
-                    else: rpc_event_type = RPCEventType.AGENT_STATUS_UPDATE; logger.warning(f"Unhandled StreamEventType '{agent_event_obj.event_type}' from agent '{agent.agent_id}'.")
-                    payload_data = {"agent_id_on_server": agent_id_on_server, **agent_event_obj.data}
-                    protocol_event_msg = ProtocolMessage.create_event(event_type=rpc_event_type, payload=payload_data)
-                    try:
-                        sse_event_str = f"event: {str(protocol_event_msg.event_type.value)}\ndata: {protocol_event_msg.to_json_str()}\n\n"
-                        await sse_client_resp.write(sse_event_str.encode('utf-8'))
-                    except ConnectionResetError: logger.info(f"SSE client reset for agent '{agent.agent_id}'."); break
-                    except Exception as send_e: logger.error(f"Error sending SSE event for agent '{agent.agent_id}': {send_e}"); break 
-                if not sse_client_resp.closed: await sse_client_resp.write_eof()
-            except asyncio.CancelledError: logger.info(f"Event streaming for agent '{agent.agent_id}' (key: {agent_id_on_server}) cancelled.")
-            except Exception as e: logger.error(f"Error in event streaming for agent '{agent.agent_id}' (key: {agent_id_on_server}): {e}", exc_info=True)
-            finally: logger.debug(f"Finished event streaming from agent '{agent.agent_id}' (key: {agent_id_on_server}).")
-
-        async def handle_http_stream_download(self, http_request: web.Request) -> web.StreamResponse:
-            # ... (method body remains the same) ...
-            agent_id_on_server = http_request.match_info.get("agent_id_on_server"); stream_id = http_request.match_info.get("stream_id")
-            if not agent_id_on_server or not stream_id: raise web.HTTPBadRequest(text="'agent_id_on_server' and 'stream_id' path params required.")
-            target_agent = self._agents.get(agent_id_on_server)
-            if not target_agent: raise web.HTTPNotFound(text=f"Agent '{agent_id_on_server}' not found.")
-            logger.info(f"HTTP stream download for agent '{target_agent.agent_id}' (key: '{agent_id_on_server}'), stream_id '{stream_id}'.")
-            if not hasattr(target_agent, "get_stream_data") or not hasattr(target_agent, "cleanup_stream_resource"):
-                raise web.HTTPNotImplemented(text=f"Agent '{target_agent.agent_id}' does not support stream retrieval.")
-            try:
-                get_stream_data_method = getattr(target_agent, "get_stream_data")
-                data_iterator: AsyncIterator[bytes] = await get_stream_data_method(stream_id)
-                response = web.StreamResponse(status=200, reason="OK", headers={"Content-Type": "application/octet-stream"})
-                await response.prepare(http_request)
-                async for chunk in data_iterator:
-                    if not isinstance(chunk, bytes): logger.error(f"Agent '{target_agent.agent_id}' stream '{stream_id}' yielded non-bytes: {type(chunk)}."); break 
-                    await response.write(chunk); await asyncio.sleep(0) 
-                await response.write_eof(); logger.info(f"Streamed data for agent '{target_agent.agent_id}', stream_id '{stream_id}'."); return response
-            except FileNotFoundError: logger.warning(f"Stream '{stream_id}' not found for agent '{target_agent.agent_id}'."); raise web.HTTPNotFound(text=f"Stream resource '{stream_id}' not found.")
-            except asyncio.CancelledError: logger.info(f"HTTP stream download for '{stream_id}' (agent '{target_agent.agent_id}') cancelled."); raise 
-            except Exception as e: logger.error(f"Error during HTTP stream download for '{stream_id}' (agent '{target_agent.agent_id}'): {e}", exc_info=True); raise web.HTTPInternalServerError(text="Error serving stream data.")
-            finally:
-                try: cleanup_method = getattr(target_agent, "cleanup_stream_resource"); await cleanup_method(stream_id); logger.debug(f"Agent '{target_agent.agent_id}' cleaned up stream '{stream_id}'.")
-                except Exception as cleanup_e: logger.error(f"Error cleaning up stream '{stream_id}': {cleanup_e}", exc_info=True)
-
-        async def start_server(self, config: AgentServerConfig):
-            # ... (method body remains the same) ...
-            if not config.sse_base_url: raise ValueError("SSE base URL required.")
-            self._app['agent_server_config'] = config; self._setup_routes(config)
-            host = config.sse_base_url.host or "0.0.0.0"; port = config.sse_base_url.port or 80
-            self._runner = web.AppRunner(self._app); await self._runner.setup()
-            self._site = web.TCPSite(self._runner, host, port)
-            try: await self._site.start(); logger.info(f"SseServerHandler started for agents {list(self._agents.keys())} on http://{host}:{port}")
-            except OSError as e: logger.error(f"Failed to start SseServer on http://{host}:{port}: {e}", exc_info=True); await self.stop_server(); raise
-            except Exception as e: logger.error(f"Unexpected error starting SseServer: {e}", exc_info=True); await self.stop_server(); raise
-
-        async def stop_server(self):
-            # ... (method body remains the same) ...
-            logger.info(f"SseServerHandler for agents {list(self._agents.keys())} stopping...")
-            for task in list(self._active_sse_forwarding_tasks.values()): 
-                if task and not task.done(): task.cancel()
-            if self._active_sse_forwarding_tasks: await asyncio.gather(*self._active_sse_forwarding_tasks.values(), return_exceptions=True)
-            self._active_sse_forwarding_tasks.clear()
-            if self._site: try: await self._site.stop()
-                except Exception as e: logger.error(f"Error stopping TCPSite: {e}", exc_info=True)
-                self._site = None
-            if self._runner: try: await self._runner.cleanup()
-                except Exception as e: logger.error(f"Error cleaning AppRunner: {e}", exc_info=True)
-                self._runner = None
-            logger.info(f"SseServerHandler for agents {list(self._agents.keys())} stopped.")
-    

autobyteus/rpc/server/stdio_server_handler.py

@@ -1,151 +0,0 @@
-# file: autobyteus/autobyteus/rpc/server/stdio_server_handler.py
-import asyncio
-import sys
-import json
-import logging
-from typing import Dict, Optional, Union
-
-from autobyteus.rpc.protocol import ProtocolMessage, MessageType, ErrorCode, RequestType
-from autobyteus.rpc.server.base_method_handler import BaseMethodHandler
-from autobyteus.agent.agent import Agent # Changed from AgentRuntime
-
-logger = logging.getLogger(__name__)
-
-class StdioServerHandler:
-    """
-    Handles RPC communication over stdio for an Agent Server.
-    Reads newline-delimited JSON ProtocolMessages from stdin, dispatches them
-    to appropriate method handlers (which operate on an Agent instance),
-    and writes responses to stdout.
-    """
-
-    def __init__(self, agent: Agent, method_handlers: Dict[Union[RequestType, str], BaseMethodHandler]): # Changed runtime to agent
-        """
-        Initializes the StdioServerHandler.
-
-        Args:
-            agent: The Agent instance this server handler is serving.
-            method_handlers: A dictionary mapping method names (RequestType or str)
-                             to their handler instances.
-        """
-        self._agent = agent # Changed from _runtime to _agent
-        self._method_handlers = method_handlers
-        self._running = False
-        logger.info(f"StdioServerHandler initialized for agent '{self._agent.agent_id}'.") # Use agent.agent_id
-
-    async def listen_and_dispatch(self) -> None:
-        """
-        Starts listening on stdin for requests and dispatches them.
-        This method runs indefinitely until stdin is closed or an error occurs.
-        """
-        self._running = True
-        logger.info(f"StdioServerHandler for agent '{self._agent.agent_id}' now listening on stdin.")
-        
-        loop = asyncio.get_event_loop()
-        reader = asyncio.StreamReader(loop=loop)
-        protocol = asyncio.StreamReaderProtocol(reader, loop=loop)
-        await loop.connect_read_pipe(lambda: protocol, sys.stdin)
-
-        try:
-            while self._running:
-                line_bytes = await reader.readline()
-                if not line_bytes:
-                    logger.info(f"StdioServerHandler for agent '{self._agent.agent_id}': stdin EOF reached. Shutting down.")
-                    self._running = False
-                    break
-                
-                line_str = line_bytes.decode().strip()
-                if not line_str:
-                    continue
-
-                request_id: Optional[str] = None
-                try:
-                    try:
-                        parsed_json = json.loads(line_str)
-                        request_id = parsed_json.get("id")
-                    except json.JSONDecodeError:
-                        pass
-
-                    message = ProtocolMessage.from_json_str(line_str)
-                    request_id = message.id 
-
-                    if message.type == MessageType.REQUEST:
-                        response_message = await self._process_request(message)
-                    else:
-                        logger.warning(f"StdioServerHandler received non-REQUEST message type: {message.type}. Ignoring.")
-                        response_message = ProtocolMessage.create_error_response(
-                            id=request_id,
-                            code=ErrorCode.INVALID_REQUEST,
-                            message="Server only accepts REQUEST messages via stdio."
-                        )
-                    
-                    await self._send_response(response_message)
-
-                except json.JSONDecodeError as e:
-                    logger.error(f"StdioServerHandler: JSONDecodeError: {e}. Raw line: '{line_str[:200]}'")
-                    err_response = ProtocolMessage.create_error_response(
-                        id=request_id,
-                        code=ErrorCode.PARSE_ERROR,
-                        message=f"Failed to parse JSON request: {e}"
-                    )
-                    await self._send_response(err_response)
-                except ValueError as e:
-                    logger.error(f"StdioServerHandler: ProtocolMessage validation error: {e}. Raw line: '{line_str[:200]}'")
-                    err_response = ProtocolMessage.create_error_response(
-                        id=request_id,
-                        code=ErrorCode.INVALID_REQUEST,
-                        message=f"Invalid request structure: {e}"
-                    )
-                    await self._send_response(err_response)
-                except Exception as e:
-                    logger.error(f"StdioServerHandler: Unexpected error processing line: {e}. Raw line: '{line_str[:200]}'", exc_info=True)
-                    err_response = ProtocolMessage.create_error_response(
-                        id=request_id,
-                        code=ErrorCode.INTERNAL_ERROR,
-                        message=f"Internal server error: {e}"
-                    )
-                    await self._send_response(err_response)
-        
-        except asyncio.CancelledError:
-            logger.info(f"StdioServerHandler for agent '{self._agent.agent_id}' listen_and_dispatch task cancelled.")
-        except Exception as e:
-            logger.error(f"StdioServerHandler for agent '{self._agent.agent_id}' fatal error in listen_and_dispatch: {e}", exc_info=True)
-        finally:
-            self._running = False
-            logger.info(f"StdioServerHandler for agent '{self._agent.agent_id}' stopped listening.")
-
-    async def _process_request(self, request_message: ProtocolMessage) -> ProtocolMessage:
-        if not request_message.method:
-            logger.warning(f"StdioServerHandler: Request message missing 'method'. ID: {request_message.id}")
-            return ProtocolMessage.create_error_response(
-                id=request_message.id,
-                code=ErrorCode.INVALID_REQUEST,
-                message="Request message must include a 'method'."
-            )
-
-        handler = self._method_handlers.get(request_message.method)
-        if not handler:
-            logger.warning(f"StdioServerHandler: No handler found for method '{request_message.method}'. ID: {request_message.id}")
-            return ProtocolMessage.create_error_response(
-                id=request_message.id,
-                code=ErrorCode.METHOD_NOT_FOUND,
-                message=f"Method '{request_message.method}' not found."
-            )
-        
-        logger.debug(f"StdioServerHandler dispatching method '{request_message.method}' (ID: {request_message.id}) to {handler.__class__.__name__}.")
-        return await handler.handle(request_message.id, request_message.params, self._agent) # Pass self._agent
-
-    async def _send_response(self, response_message: ProtocolMessage) -> None:
-        try:
-            json_response = response_message.to_json_str()
-            loop = asyncio.get_event_loop()
-            await loop.run_in_executor(None, lambda: sys.stdout.write(json_response + '\n'))
-            await loop.run_in_executor(None, sys.stdout.flush)
-            logger.debug(f"StdioServerHandler sent response (ID: {response_message.id}, Type: {response_message.type}).")
-        except Exception as e:
-            logger.error(f"StdioServerHandler failed to send response: {e}", exc_info=True)
-
-    def stop(self):
-        logger.info(f"StdioServerHandler for agent '{self._agent.agent_id}' stop requested.")
-        self._running = False
-

autobyteus/rpc/server_main.py

@@ -1,198 +0,0 @@
-# file: autobyteus/autobyteus/rpc/server_main.py
-import asyncio
-import logging
-import argparse
-import signal
-import sys 
-from typing import Optional
-
-from autobyteus.agent.registry.agent_definition import AgentDefinition
-from autobyteus.agent.registry.agent_registry import default_definition_registry, default_agent_registry
-from autobyteus.agent.agent import Agent 
-from autobyteus.llm.models import LLMModel 
-
-from autobyteus.rpc.config import AgentServerConfig, default_agent_server_registry
-from autobyteus.rpc.server import AgentServerEndpoint
-from autobyteus.rpc.transport_type import TransportType
-
-try:
-    from autobyteus.agent.input_processor import PassthroughInputProcessor
-except ImportError:
-    print("WARNING: PassthroughInputProcessor not found, EchoAgentDefinition in server_main might fail if used.", file=sys.stderr)
-
-
-logging.basicConfig(
-    level=logging.INFO,
-    format='%(asctime)s - %(levelname)s - %(name)s - [%(process)d] - %(message)s',
-    stream=sys.stderr
-)
-logger = logging.getLogger(__name__)
-
-
-ECHO_AGENT_DEF: Optional[AgentDefinition] = None
-try:
-    if not default_definition_registry.get("EchoAgent", "echo_responder"):
-        ECHO_AGENT_DEF = AgentDefinition(
-            name="EchoAgent",
-            role="echo_responder",
-            description="A simple agent that echoes back user messages.",
-            system_prompt="You are an echo agent. Repeat the user's message precisely.",
-            tool_names=[], 
-            input_processor_names=["PassthroughInputProcessor"], # Assumes PassthroughInputProcessor is registered
-            llm_response_processor_names=[] 
-        )
-        logger.info(f"Example AgentDefinition '{ECHO_AGENT_DEF.name}' created and auto-registered for server_main.")
-    else:
-        ECHO_AGENT_DEF = default_definition_registry.get("EchoAgent", "echo_responder")
-        logger.info(f"Example AgentDefinition 'EchoAgent' already registered. Using existing one for server_main.")
-except Exception as e:
-    logger.error(f"Could not create/retrieve example EchoAgentDefinition: {e}. server_main might fail if it's requested.")
-
-
-shutdown_event = asyncio.Event()
-agent_global: Optional[Agent] = None 
-server_endpoint_global: Optional[AgentServerEndpoint] = None
-
-async def main():
-    global agent_global, server_endpoint_global
-
-    parser = argparse.ArgumentParser(description="AutoByteUs Agent RPC Server") 
-    parser.add_argument("--agent-def-name", type=str, required=True, help="Name of the AgentDefinition.")
-    parser.add_argument("--agent-def-role", type=str, required=True, help="Role of the AgentDefinition.")
-    parser.add_argument("--llm-model-name", type=str, required=True, help="Name of the LLMModel (e.g., 'GPT_4o_API'). This is the string name for the model, not the enum member itself.")
-    parser.add_argument("--server-config-id", type=str, required=True, help="ID of the AgentServerConfig.")
-    
-    args = parser.parse_args()
-    logger.info(f"server_main starting with args: {args}")
-
-    agent_definition = default_definition_registry.get(args.agent_def_name, args.agent_def_role)
-    if not agent_definition:
-        logger.error(f"AgentDefinition not found for name='{args.agent_def_name}', role='{args.agent_def_role}'.")
-        sys.exit(1)
-
-    # The llm_model_name from args is already a string, which is what create_agent now expects.
-    # We still need to validate if it's a known model name for robustness,
-    # though create_agent (via AgentFactory -> AgentConfig) will also do this.
-    try:
-        LLMModel[args.llm_model_name.upper()] # Validate if the name maps to a known LLMModel enum member
-    except KeyError:
-        logger.error(f"LLMModel name '{args.llm_model_name}' provided via --llm-model-name is not a recognized LLMModel. Available: {[m.name for m in LLMModel]}")
-        sys.exit(1)
-
-    server_config = default_agent_server_registry.get_config(args.server_config_id)
-    if not server_config:
-        logger.error(f"AgentServerConfig not found for server_config_id='{args.server_config_id}'.")
-        sys.exit(1)
-    
-    try:
-        # UPDATED: Pass llm_model_name directly as a string.
-        # AgentRegistry.create_agent -> AgentFactory.create_agent_runtime -> AgentFactory.create_agent_context
-        # -> AgentConfig now takes llm_model_name: str.
-        agent = default_agent_registry.create_agent(
-            definition=agent_definition,
-            llm_model_name=args.llm_model_name # Pass the string name
-            # custom_llm_config, custom_tool_config, etc., can be added here if needed
-        )
-        agent_global = agent
-    except Exception as e:
-        logger.error(f"Failed to create Agent instance: {e}", exc_info=True)
-        sys.exit(1)
-    
-    logger.info(f"Agent instance created with agent_id '{agent.agent_id}'.")
-
-    server_endpoint = AgentServerEndpoint(agent) 
-    server_endpoint_global = server_endpoint
-    logger.info(f"AgentServerEndpoint instantiated for agent '{agent.agent_id}'.")
-
-    try:
-        logger.info(f"Starting Agent '{agent.agent_id}' (runtime execution loop)...")
-        agent.start()
-        
-        logger.info(f"Starting AgentServerEndpoint for agent '{agent.agent_id}' with config '{server_config.server_id}' (Transport: {server_config.transport_type.value})...")
-        await server_endpoint.start(server_config) 
-
-        logger.info(f"Agent '{agent.agent_id}' is now hosted and listening via RPC ({server_config.transport_type.value}).")
-        await shutdown_event.wait()
-
-    except Exception as e:
-        logger.error(f"Error during server startup or main execution: {e}", exc_info=True)
-    finally:
-        logger.info("server_main performing final shutdown...")
-        if server_endpoint_global and server_endpoint_global.is_running:
-            logger.info("Stopping AgentServerEndpoint...")
-            await server_endpoint_global.stop()
-        
-        if agent_global and agent_global.is_running: 
-            logger.info(f"Stopping Agent '{agent_global.agent_id}'...")
-            await agent_global.stop()
-        
-        logger.info("server_main has shut down.")
-
-async def initiate_shutdown_from_signal():
-    logger.debug("Initiating shutdown via signal...")
-    shutdown_event.set()
-
-if __name__ == "__main__":
-    # Ensure input processors are available if EchoAgentDefinition needs them
-    # This try-except is more for robustness during development/examples.
-    try:
-        # This import ensures that processors like PassthroughInputProcessor are registered
-        # if EchoAgentDefinition (or others used by server_main) depends on them.
-        from autobyteus.agent import input_processor # type: ignore
-    except ImportError as e_proc:
-        logger.warning(f"Could not import autobyteus.agent.input_processor: {e_proc}. "
-                       "Make sure custom input processors are correctly installed and registered if used by agent definitions.")
-
-
-    # Example STDIO server config (remains for testing server_main directly)
-    stdio_cfg_id = "default_stdio_server_cfg"
-    if not default_agent_server_registry.get_config(stdio_cfg_id):
-        example_stdio_cfg = AgentServerConfig(
-            server_id=stdio_cfg_id,
-            transport_type=TransportType.STDIO,
-            # stdio_command is usually for launching this script itself as a subprocess.
-            # For direct execution of server_main.py, this specific command isn't directly used
-            # but a valid config is needed if --server-config-id=default_stdio_server_cfg is passed.
-            stdio_command=["python", "-m", "autobyteus.rpc.server_main",
-                           "--agent-def-name", "EchoAgent", 
-                           "--agent-def-role", "echo_responder",
-                           "--llm-model-name", "GPT_4O_API", # Example model name
-                           "--server-config-id", stdio_cfg_id
-                          ] 
-        )
-        default_agent_server_registry.register_config(example_stdio_cfg)
-        logger.info(f"Registered example STDIOServerConfig '{stdio_cfg_id}'.")
-
-    # Example SSE server config
-    sse_cfg_id = "default_sse_server_cfg"
-    if not default_agent_server_registry.get_config(sse_cfg_id):
-        example_sse_cfg = AgentServerConfig(
-            server_id=sse_cfg_id, # This ID is for the server config itself
-            transport_type=TransportType.SSE,
-            sse_base_url="http://localhost:8765", 
-            sse_request_endpoint="/invoke_rpc", # Changed from /rpc to avoid clash with potential future global /rpc
-            sse_events_endpoint="/agent_events" # Changed from /events
-        )
-        default_agent_server_registry.register_config(example_sse_cfg)
-        logger.info(f"Registered example SseServerConfig '{sse_cfg_id}'.")
-
-    loop = asyncio.get_event_loop()
-    for sig_name_str in ('SIGINT', 'SIGTERM'):
-        sig_enum_member = getattr(signal, sig_name_str, None)
-        if sig_enum_member:
-            try:
-                loop.add_signal_handler(sig_enum_member, lambda s=sig_name_str: asyncio.create_task(initiate_shutdown_from_signal()))
-            except (ValueError, RuntimeError, NotImplementedError) as e: # Might fail on Windows for SIGTERM
-                 logger.warning(f"Could not set signal handler for {sig_name_str} on this platform: {e}.")
-    try:
-        loop.run_until_complete(main())
-    except KeyboardInterrupt:
-        logger.info("KeyboardInterrupt received in main. Shutting down.")
-        if not shutdown_event.is_set(): 
-            if loop.is_running():
-                asyncio.ensure_future(initiate_shutdown_from_signal(), loop=loop)
-            else: # Should not happen if loop was running
-                loop.run_until_complete(initiate_shutdown_from_signal())
-    finally:
-        logger.info("Asyncio loop in server_main is finalizing.")
-

autobyteus/rpc/transport_type.py

@@ -1,13 +0,0 @@
-# file: autobyteus/autobyteus/rpc/transport_type.py
-from enum import Enum
-
-class TransportType(str, Enum):
-    """
-    Defines the transport mechanisms supported for RPC communication.
-    """
-    STDIO = "stdio"
-    SSE = "sse"  # Server-Sent Events over HTTP
-
-    def __str__(self) -> str:
-        return self.value
-

autobyteus/tools/bash/__init__.py

@@ -1,2 +0,0 @@
-# This file makes 'bash' a package.
-# from .bash_executor import bash_executor # Optionally export

autobyteus/tools/bash/bash_executor.py

@@ -1,100 +0,0 @@
-import asyncio
-import subprocess
-import logging
-import shutil
-import tempfile
-from typing import TYPE_CHECKING, Optional
-
-from autobyteus.tools import tool 
-from autobyteus.tools.tool_category import ToolCategory
-
-if TYPE_CHECKING:
-    from autobyteus.agent.context import AgentContext
-
-logger = logging.getLogger(__name__)
-
-@tool(name="execute_bash", category=ToolCategory.SYSTEM)
-async def bash_executor(context: Optional['AgentContext'], command: str) -> str:
-    """
-    Executes bash commands using the '/bin/bash' interpreter.
-    On success, it returns a formatted string containing the command's standard output (stdout) and/or diagnostic logs.
-    On failure, it raises an exception.
-    - If a command has only stdout, its content is returned directly.
-    - If a command has diagnostic output (from stderr), it will be included and labeled as 'LOGS' in the output.
-    'command' is the bash command string to be executed.
-    The command is executed in the agent's workspace directory if available.
-    """
-    if not shutil.which("bash"):
-        error_msg = "'bash' executable not found in system PATH. The execute_bash tool cannot be used."
-        logger.error(error_msg)
-        raise FileNotFoundError(error_msg)
-        
-    agent_id_str = context.agent_id if context else "Non-Agent"
-    
-    effective_cwd = None
-    log_cwd_source = ""
-
-    if context and hasattr(context, 'workspace') and context.workspace:
-        try:
-            base_path = context.workspace.get_base_path()
-            if base_path and isinstance(base_path, str):
-                effective_cwd = base_path
-                log_cwd_source = f"agent workspace: {effective_cwd}"
-            else:
-                logger.warning(f"Agent '{agent_id_str}' has a workspace, but it provided an invalid base path ('{base_path}'). "
-                               f"Falling back to system temporary directory.")
-        except Exception as e:
-            logger.warning(f"Could not retrieve workspace for agent '{agent_id_str}': {e}. "
-                           f"Falling back to system temporary directory.")
-
-    if not effective_cwd:
-        effective_cwd = tempfile.gettempdir()
-        log_cwd_source = f"system temporary directory: {effective_cwd}"
-
-    logger.debug(f"Functional execute_bash tool executing for '{agent_id_str}': {command} in cwd from {log_cwd_source}")
-
-    try:
-        # Explicitly use 'bash -c' for reliable execution
-        process = await asyncio.create_subprocess_exec(
-            'bash', '-c', command,
-            stdout=asyncio.subprocess.PIPE,
-            stderr=asyncio.subprocess.PIPE,
-            cwd=effective_cwd
-        )
-        stdout, stderr = await process.communicate()
-        
-        stdout_output = stdout.decode().strip() if stdout else ""
-        stderr_output = stderr.decode().strip() if stderr else ""
-
-        if process.returncode != 0:
-            error_message = stderr_output if stderr_output else "Unknown error"
-            if not error_message and process.returncode != 0:
-                error_message = f"Command failed with exit code {process.returncode} and no stderr output."
-            
-            logger.error(f"Command '{command}' failed with return code {process.returncode}: {error_message}")
-            raise subprocess.CalledProcessError(
-                returncode=process.returncode,
-                cmd=command,
-                output=stdout_output,
-                stderr=error_message
-            )
-        
-        # Adaptive return for successful commands to provide maximum context to the agent.
-        if stdout_output and stderr_output:
-            return f"STDOUT:\n{stdout_output}\n\nLOGS:\n{stderr_output}"
-        elif stdout_output:
-            return stdout_output  # Keep it simple for commands with only stdout
-        elif stderr_output:
-            return f"LOGS:\n{stderr_output}"
-        else:
-            return "Command executed successfully with no output."
-
-    except subprocess.CalledProcessError:
-        raise
-    except FileNotFoundError:
-        # This can be raised by create_subprocess_exec if 'bash' is not found, despite the initial check.
-        logger.error("'bash' executable not found when attempting to execute command. Please ensure it is installed and in the PATH.")
-        raise
-    except Exception as e: 
-        logger.exception(f"An error occurred while preparing or executing command '{command}': {str(e)}")
-        raise RuntimeError(f"Failed to execute command '{command}': {str(e)}")

autobyteus/tools/browser/__init__.py

@@ -1,2 +0,0 @@
-# This file makes 'browser' a package.
-# It can be empty or import submodules/subpackages.