Files
gcp_solution_architecture_a…/app/main.py
Jonathan Boniface 654370bb46 feat: all four evaluation cases pass; intake, checklist review, thresholds
Case 04 (interactive)
- A scripted answer may name who it is for, so facts written for
  requirements discovery are not given to a Specialist confirming a draft.
- A reply that restates what the agreed requirements already say is read
  as an answer, not a request for changes.
- With a user present, a first submission is refused until the user has
  been shown a draft of that Deliverable (CONFIRM_DRAFTS).

Routing and reviews
- Intake: a message that starts something is read first. A question is
  answered and starts nothing; a change to delivered work starts as a new
  request with a note, until Change requests are built.
- Requirements and recommendations list what infrastructure code can show
  (conditions) apart from what it cannot (outside_code); the latter needs
  no Check and validation proposes nothing for it.
- A requirements review, "names no products", behind its own switch (off).
- Each pillar advisor reviews its pillar's checklist; the engine writes the
  reviews into the design recommendations. The judged checklist check went
  from 9-45% a pillar to 100% in one run of case 04.

Evaluation
- Per-case thresholds for Revisions, seconds and tokens, set from every
  completed run on this build.
- A progress file after every agent run, so an interrupted run keeps its
  time and tokens.
- eval/calibrate_judge.py with a 32-question set awaiting a person's
  labels. Unlabelled: Jev stable at 1.00, Gemini 0.92, agreeing on 0.91.

Smaller
- An Execution that ends with warnings writes its Deliverables, with the
  warnings and each status in the manifest.
- CI installs the application's dependencies before linting and testing.
- A load-balancer pattern in the IaC patterns Skill.

Plans record nine runs of 2026-10-08. Iteration 6 is complete.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-09 09:32:57 +01:00

131 lines
4.6 KiB
Python

"""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"),
customer_case=body.get("customer_case"),
pre_approved=True,
allow_cloud_read=bool(body.get("allow_cloud_read", False)),
)
except ValueError as exc:
return JSONResponse({"error": str(exc)}, status_code=400)
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, assembly.intake
),
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()