"""The LangGraph that holds an Execution (ADR-0003). START -> orchestrator_turn orchestrator_turn -> specialist_task x N (Send, parallel) -> orchestrator_turn orchestrator_turn -> await_user (interrupt) -> orchestrator_turn orchestrator_turn -> finalize -> END orchestrator_turn -> end_with_warnings -> END The nodes live in app/nodes/execution_nodes.py; they route with Command and Send, so only the fixed edges are declared here. """ from __future__ import annotations from collections.abc import Mapping from pathlib import Path from typing import Any, cast from langgraph.graph import END, START, StateGraph from app.adk.runtime import AgentRuntime, RoleSpec, RunLimiter, ToolFactory from app.nodes.execution_nodes import make_execution_nodes from app.recorder import ExecutionRecorder from app.states.execution_state import ExecutionState def build_execution_graph( *, runtime: AgentRuntime, roles: Mapping[str, RoleSpec], recorder: ExecutionRecorder, output_root: Path, max_orchestrator_turns: int = 100, tool_factory: ToolFactory | None = None, limiter: RunLimiter | None = None, skill_versions: Mapping[str, str] | None = None, ) -> StateGraph: nodes = make_execution_nodes( runtime=runtime, roles=roles, recorder=recorder, output_root=output_root, max_orchestrator_turns=max_orchestrator_turns, tool_factory=tool_factory, limiter=limiter, skill_versions=skill_versions, ) graph = StateGraph(ExecutionState) graph.add_node("orchestrator_turn", cast(Any, nodes.orchestrator_turn)) # Specialist tasks receive their Send payload, not the Execution state. graph.add_node("specialist_task", cast(Any, nodes.specialist_task)) graph.add_node("await_user", cast(Any, nodes.await_user)) graph.add_node("finalize", cast(Any, nodes.finalize)) graph.add_node("end_with_warnings", cast(Any, nodes.end_with_warnings)) graph.add_edge(START, "orchestrator_turn") graph.add_edge("specialist_task", "orchestrator_turn") graph.add_edge("finalize", END) graph.add_edge("end_with_warnings", END) return graph