"""The A2A server: JSON-RPC at /a2a, the agent card, health, and pre-approved /generate. Run with: python -m app.main """ from __future__ import annotations import logging from collections.abc import AsyncIterator, Callable from contextlib import AbstractAsyncContextManager, asynccontextmanager import click import uvicorn from a2a.server.request_handlers.default_request_handler_v2 import ( DefaultRequestHandlerV2, ) from a2a.server.routes.agent_card_routes import create_agent_card_routes from a2a.server.routes.jsonrpc_routes import create_jsonrpc_routes from a2a.server.tasks import InMemoryTaskStore from a2a.utils.constants import AGENT_CARD_WELL_KNOWN_PATH from starlette.applications import Starlette from starlette.requests import Request from starlette.responses import JSONResponse from starlette.routing import Route from app.a2a_server import SolutionArchitectExecutor from app.agent import Assembly, open_assembly from app.card import A2A_PATH, build_agent_card from app.config import Settings, get_settings from app.presentation import to_generate_response logger = logging.getLogger(__name__) AssemblyFactory = Callable[[Settings], AbstractAsyncContextManager[Assembly]] LEGACY_CARD_PATH = "/.well-known/agent.json" def create_app( settings: Settings | None = None, assembly_factory: AssemblyFactory = open_assembly, ) -> Starlette: settings = settings or get_settings() card = build_agent_card(settings) async def health(request: Request) -> JSONResponse: assembly: Assembly = request.app.state.assembly return JSONResponse( { "status": "healthy", "agent": settings.AGENT_NAME, "version": settings.AGENT_VERSION, "cloud_provider": assembly.bundle.name, "mcp_discovery_gaps": assembly.mcp_gaps, } ) async def generate(request: Request) -> JSONResponse: """Pre-approved, one-shot Execution for batch and evaluation callers.""" assembly: Assembly = request.app.state.assembly try: body = await request.json() except ValueError: body = {} workflow_request = str(body.get("request") or "").strip() if not workflow_request: return JSONResponse({"error": "'request' is required"}, status_code=400) try: interaction = await assembly.engine.start( workflow_request, session_id=body.get("session_id"), pre_approved=True, allow_cloud_read=bool(body.get("allow_cloud_read", False)), ) except Exception as exc: logger.exception("/generate failed") return JSONResponse( {"error": f"{type(exc).__name__}: {exc}"}, status_code=500 ) return JSONResponse(to_generate_response(interaction, assembly.roles)) @asynccontextmanager async def lifespan(app: Starlette) -> AsyncIterator[None]: async with assembly_factory(settings) as assembly: handler = DefaultRequestHandlerV2( agent_executor=SolutionArchitectExecutor(assembly.engine), task_store=InMemoryTaskStore(), agent_card=card, ) app.state.assembly = assembly app.state.request_handler = handler app.router.routes.extend( create_jsonrpc_routes(handler, A2A_PATH, enable_v0_3_compat=True) ) try: yield finally: await handler.aclose() return Starlette( routes=[ Route("/health", health, methods=["GET"]), Route("/generate", generate, methods=["POST"]), *create_agent_card_routes(card, card_url=AGENT_CARD_WELL_KNOWN_PATH), *create_agent_card_routes(card, card_url=LEGACY_CARD_PATH), ], lifespan=lifespan, ) @click.command() @click.option("--host", default=None, help="Host to bind (default A2A_HOST)") @click.option("--port", default=None, type=int, help="Port (default A2A_PORT)") def main(host: str | None, port: int | None) -> None: """Serve the solution architect agent over A2A.""" settings = get_settings() logging.basicConfig(level=settings.LOG_LEVEL.upper()) uvicorn.run( create_app(settings), host=host or settings.A2A_HOST, port=port or settings.A2A_PORT, ) if __name__ == "__main__": main()