95 lines
3.3 KiB
Python
95 lines
3.3 KiB
Python
"""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 execution_engine.adk.runtime import (
|
|
AgentRuntime,
|
|
Decider,
|
|
RoleSpec,
|
|
RunLimiter,
|
|
SubmissionReview,
|
|
ToolFactory,
|
|
)
|
|
from execution_engine.nodes.execution_nodes import make_execution_nodes
|
|
from execution_engine.nodes.router import OrchestratorPolicy
|
|
from execution_engine.recorder import ExecutionRecorder
|
|
from execution_engine.states.execution_state import ExecutionState
|
|
from execution_engine.tools.scoping import Scoping
|
|
from execution_engine.workflows.workflow import Workflow
|
|
|
|
|
|
def build_execution_graph(
|
|
*,
|
|
workflow: Workflow,
|
|
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,
|
|
orchestrator: OrchestratorPolicy | None = None,
|
|
submission_review: SubmissionReview | None = None,
|
|
confirm_drafts: bool = False,
|
|
decider: Decider | None = None,
|
|
reworded_threshold: float = 0.25,
|
|
guard_user_text: bool = False,
|
|
guard_threshold: float = 0.75,
|
|
skill_references: Mapping[str, Mapping[str, Mapping[str, str]]] | None = None,
|
|
skill_threshold: float = 1.25,
|
|
assess_at_end: bool = False,
|
|
scoping: Scoping | None = None,
|
|
) -> StateGraph:
|
|
nodes = make_execution_nodes(
|
|
workflow=workflow,
|
|
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,
|
|
orchestrator=orchestrator,
|
|
submission_review=submission_review,
|
|
confirm_drafts=confirm_drafts,
|
|
decider=decider,
|
|
reworded_threshold=reworded_threshold,
|
|
guard_user_text=guard_user_text,
|
|
guard_threshold=guard_threshold,
|
|
skill_references=skill_references,
|
|
skill_threshold=skill_threshold,
|
|
assess_at_end=assess_at_end,
|
|
scoping=scoping,
|
|
)
|
|
|
|
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
|