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>
180 lines
7.1 KiB
Python
180 lines
7.1 KiB
Python
"""Maps A2A tasks onto Executions: a task is an Execution, its context is the Session.
|
|
|
|
A new task starts an Execution; a message on an input-required task answers the
|
|
Execution's prompt. Approvals and permissions count only as structured data parts,
|
|
never as free text.
|
|
|
|
Before a new task starts anything its message is read (app/nodes/intake.py): a
|
|
question is answered and starts nothing, and a change to delivered work is started
|
|
as a new request with a note saying so, until Change requests are built.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import logging
|
|
from collections.abc import Mapping
|
|
from typing import Any
|
|
|
|
from a2a.helpers.proto_helpers import (
|
|
get_data_parts,
|
|
new_data_part,
|
|
new_task,
|
|
new_text_part,
|
|
)
|
|
from a2a.server.agent_execution import AgentExecutor, RequestContext
|
|
from a2a.server.events import EventQueue
|
|
from a2a.server.tasks import TaskUpdater
|
|
from a2a.types import TaskState
|
|
from google.protobuf import json_format
|
|
|
|
from app.agent import ExecutionEngine, Interaction
|
|
from app.nodes.execution_nodes import GUIDE_FILENAME
|
|
from app.nodes.intake import ABOUT, CHANGE_NOTE, CHANGE_REQUEST, QUESTION, Intake
|
|
from app.presentation import describe_prompt
|
|
from app.workflows.deliverables import DeliverableKind
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
STRUCTURED_REPLY_KEYS = ("approval", "permission")
|
|
|
|
|
|
class SolutionArchitectExecutor(AgentExecutor):
|
|
def __init__(self, engine: ExecutionEngine, intake: Intake | None = None) -> None:
|
|
self._engine = engine
|
|
self._intake = intake
|
|
|
|
async def execute(self, context: RequestContext, event_queue: EventQueue) -> None:
|
|
task_id = context.task_id or ""
|
|
updater = TaskUpdater(event_queue, task_id, context.context_id or "")
|
|
new = context.current_task is None
|
|
note: str | None = None
|
|
try:
|
|
if new:
|
|
history = [context.message] if context.message is not None else []
|
|
await event_queue.enqueue_event(
|
|
new_task(
|
|
task_id,
|
|
context.context_id or "",
|
|
TaskState.TASK_STATE_SUBMITTED,
|
|
history=history,
|
|
)
|
|
)
|
|
await updater.start_work()
|
|
options = _options(context)
|
|
# A pre-approved caller is a batch job: it sends work, not questions.
|
|
if self._intake and not options.get("pre_approved"):
|
|
reading = await self._intake.read(
|
|
context.get_user_input(),
|
|
options.get("customer_case"),
|
|
scope=task_id,
|
|
)
|
|
if reading.kind == QUESTION:
|
|
await updater.complete(
|
|
updater.new_agent_message(
|
|
[
|
|
new_text_part(ABOUT),
|
|
new_data_part(
|
|
{"status": "answered", "intake": QUESTION}
|
|
),
|
|
]
|
|
)
|
|
)
|
|
return
|
|
if reading.kind == CHANGE_REQUEST:
|
|
note = CHANGE_NOTE
|
|
interaction = await self._engine.start(
|
|
context.get_user_input(),
|
|
session_id=context.context_id,
|
|
customer_case=options.get("customer_case"),
|
|
execution_id=task_id,
|
|
pre_approved=bool(options.get("pre_approved", False)),
|
|
allow_cloud_read=options.get("allow_cloud_read"),
|
|
)
|
|
else:
|
|
await updater.start_work()
|
|
interaction = await self._engine.resume(task_id, _reply(context))
|
|
except Exception as exc:
|
|
logger.exception("Execution %s failed", task_id)
|
|
await updater.failed(
|
|
updater.new_agent_message(
|
|
[
|
|
new_text_part(
|
|
f"The Execution failed: {type(exc).__name__}: {exc}"
|
|
)
|
|
]
|
|
)
|
|
)
|
|
return
|
|
await self._publish(interaction, updater, note if new else None)
|
|
|
|
async def cancel(self, context: RequestContext, event_queue: EventQueue) -> None:
|
|
# The checkpoint stays; cancelling only ends the A2A task.
|
|
updater = TaskUpdater(
|
|
event_queue, context.task_id or "", context.context_id or ""
|
|
)
|
|
await updater.cancel()
|
|
|
|
async def _publish(
|
|
self, interaction: Interaction, updater: TaskUpdater, note: str | None = None
|
|
) -> None:
|
|
if interaction.status == "awaiting_user" and interaction.prompt is not None:
|
|
prompt = dict(interaction.prompt)
|
|
await updater.requires_input(
|
|
updater.new_agent_message(
|
|
[
|
|
*([new_text_part(note)] if note else []),
|
|
new_text_part(describe_prompt(prompt)),
|
|
new_data_part({"prompt": prompt}),
|
|
]
|
|
)
|
|
)
|
|
return
|
|
|
|
deliverables: Mapping[str, Mapping[str, Any]] = interaction.state.get(
|
|
"deliverables", {}
|
|
)
|
|
guide = deliverables.get(DeliverableKind.SOLUTION_GUIDE.value)
|
|
if guide:
|
|
await updater.add_artifact(
|
|
[new_text_part(guide["content"], media_type="text/markdown")],
|
|
name=GUIDE_FILENAME,
|
|
)
|
|
for kind, deliverable in deliverables.items():
|
|
for name, content in deliverable.get("attachments", {}).items():
|
|
await updater.add_artifact(
|
|
[new_text_part(content)], name=name, metadata={"deliverable": kind}
|
|
)
|
|
|
|
warnings = list(interaction.state.get("warnings", []))
|
|
summary = (
|
|
"The solution architecture is complete and approved."
|
|
if interaction.status == "completed"
|
|
else "The Execution ended with warnings: " + "; ".join(warnings)
|
|
)
|
|
await updater.complete(
|
|
updater.new_agent_message(
|
|
[
|
|
new_text_part(summary),
|
|
new_data_part({"status": interaction.status, "warnings": warnings}),
|
|
]
|
|
)
|
|
)
|
|
|
|
|
|
def _options(context: RequestContext) -> dict[str, Any]:
|
|
options: dict[str, Any] = {}
|
|
if context.message is not None and context.message.HasField("metadata"):
|
|
options.update(json_format.MessageToDict(context.message.metadata))
|
|
options.update(context.metadata)
|
|
return options
|
|
|
|
|
|
def _reply(context: RequestContext) -> dict[str, Any]:
|
|
if context.message is not None:
|
|
for data in get_data_parts(list(context.message.parts)):
|
|
if isinstance(data, Mapping) and any(
|
|
k in data for k in STRUCTURED_REPLY_KEYS
|
|
):
|
|
return {k: data[k] for k in STRUCTURED_REPLY_KEYS if k in data}
|
|
return {"reply": context.get_user_input()}
|