驳回出口(后端):审批、补充输入、编辑稿件、动作确认、代码和工具审批、双盲裁决接了「驳回」出口时沿它往下走

以前这六类关卡被驳回一律抛 NodeRejected,运行收成 cancelled + end_reason=rejected,没有「驳回之后走另一条路」
(docs/design/orchestration-round/00-总方案.md §3)。现在画布上多一个可选的「驳回」出口(sourceHandle="rejected",和
分支、审批同一套连线机制):

- engine/schema:GATE_TYPES(人工、调用工具、沙箱代码、双盲复算)、reject_targets(驳回出口连到哪几步)、approve_mode;
  画布校验:别的节点接驳回出口报错(graph.reject_exit_invalid,条件分支的 case 标识可以叫 rejected,不算);审批同时设了
  「驳回即终止运行」和驳回边的给一条提示(human.stop_on_reject_exit)
- engine/compiler:接了驳回出口的关卡按出口路由(驳回出口 / 其余是普通出口,连线没写 sourceHandle 的照样是普通出口);
  NodeRejected 被接住时这一步正常结束:产出 NodeRejected.exit_payload()(rejected、decision、actor、note、kind、text,
  审批另带 approved=false、「结果存为变量」照旧写 false),node.finished 带 outcome=rejected、哪种关卡、结论、谁、备注、
  转到哪几步(to),trail 记 outcome=rejected;不重试、不被「出错时继续」接住,照旧
- engine/context:NodeRejected 加 stop(审批明说了驳回即终止的,驳回边照旧走不到)和 exit_payload;动作确认抛在发送之前,
  走出口时什么都没发
- engine/runner:成功结束的运行途经驳回出口时,run.finished 带 rejected_via(在哪一步、谁、结论、转到哪),照实说「途经
  驳回」;没有途经的终态事件一字不变
- engine/governance:发布检查各级都拦「驳回出口那条路走不到成果节点或结束」(reject_exit.no_end);退回上游再问一次的放过
- engine/layout:驳回出口排在普通出口下面
- apps/resolve:实例进度写「被驳回,转到「X」」(动作确认写「未确认(被驳回),转到…」,超时驳回写「超时驳回,转到…」);
  实例状态(实例页头、列表、通知同一句)写「「x」被驳回,转到「y」」,走到另一个成果节点的照旧写那个成果节点;退回修改后
  又批准了的按批准算;子工作流里的步骤不进实例进度
- 没接出口:行为一字不变(node.failed reason=rejected、运行 cancelled + rejected);审批没设驳回即终止、没接驳回边的老规矩
  照旧。接了驳回边的审批,实例进度那一步的说法从「已驳回」改成「被驳回,转到「已退回」」(test_app_instance_page 跟着改)

另:engine/context 的 RunContext 加 prefix / global_id、事件经 stream_writer 发(子工作流把父运行的写入口交下来),
这一步本身不改变最外层的事件,下一个提交接上子工作流

测试:test_reject_exit(五类关卡接了出口各走一遍、批准走普通出口、超时驳回走出口、没接一字不变、驳回即终止优先、
重试和出错时继续不管驳回、退回修改再问一次、校验与发布检查、布局、实例进度);test_process_actions(动作确认走出口
不发送);test_dual_check_node(裁决走出口)
This commit is contained in:
ThearchyHelios
2026-10-18 15:56:20 +08:00
parent 3f3e39e4d5
commit d57cdcaffc
14 changed files with 684 additions and 36 deletions
+59 -4
View File
@@ -15,7 +15,10 @@ from app.engine.expressions import open_template_scope, template_scope
from app.engine.nodes import (
challenge, control, dual_check, human, io, knowledge, llm, merge, metrics, multi, report, tools,
)
from app.engine.schema import GraphNode, GraphSpec, NodeType, back_edges, innermost_loops
from app.engine.schema import (
GATE_TYPES, REJECT_HANDLE, GraphNode, GraphSpec, NodeType, approve_mode, back_edges, innermost_loops,
reject_targets,
)
from app.engine.state import GraphState
from app.process.actions import ActionPending
@@ -103,7 +106,7 @@ def _wrap(
payload,
kind="node_output",
run_id=run_ctx.run_id,
node_id=node.id,
node_id=run_ctx.global_id(node.id),
meta={"type": str(node.type), "attempt": attempt + 1},
)
except Exception: # noqa: BLE001 - 工件写失败不该毁掉运行本身
@@ -124,7 +127,7 @@ def _wrap(
# 这一步新记进证据台账的条目(口径卡的指标集工件等)。事件在封存范围
# 内,证据接口从这里出发找工件,不去读可以事后插行的 artifacts 表。
# 没产出证据的节点不带这个键,事件和以前一字不差
**({"evidence": updates["evidence"]} if updates.get("evidence") else {}),
**_own_evidence(updates, node.id),
)
trail = {
"node_id": node.id,
@@ -169,6 +172,11 @@ def _wrap(
break
elapsed = int((time.perf_counter() - started) * 1000)
if isinstance(last_error, NodeRejected) and not last_error.stop \
and (targets := reject_targets(run_ctx.spec, node)):
# 接了「驳回」出口:驳回不让运行结束,这一步正常结束、沿驳回那条边往下走(总方案 §3)。没接的照旧往下收成
# node.failed(reason=rejected)+ 运行 cancelled,一字不变
return await _rejected_exit(node, ctx, last_error, targets, elapsed=elapsed, attempt=attempt + 1)
message = _describe(last_error)
# node_id 要带上:前端靠它把出错的节点从"转圈"收敛成"失败"。
# error 是给人看的那句,原始异常放 detail,排查的人照样拿得到。
@@ -196,6 +204,48 @@ def _wrap(
return _entry
def _own_evidence(updates: dict[str, Any], node_id: str) -> dict[str, Any]:
"""node.finished 上带的台账条目:这一步自己新记的。子工作流节点交回父图的条目(节点 id 是「子工作流节点 id/…」,
multi.run_subgraph)不带:子工作流里那几个节点自己的 node.finished 已经带着它们(节点 id 同样带前缀),再记一遍,
证据接口会把查询认成子工作流节点自己查的。"""
entries = [e for e in updates.get("evidence") or []
if not (isinstance(e, dict) and str(e.get("node_id") or "").startswith(f"{node_id}/"))]
return {"evidence": entries} if entries else {}
async def _rejected_exit(node: GraphNode, ctx: NodeContext, error: NodeRejected, targets: list[str], *,
elapsed: int, attempt: int) -> dict[str, Any]:
"""被驳回、接了「驳回」出口:这一步正常结束(node.finished 带 outcome=rejected 和哪种关卡、结论、谁、备注、转到哪几步),
产出 NodeRejected.exit_payload(),路由按它的 __decision__ 走驳回那条边。
动作确认被驳回时 NodeRejected 抛在发送之前,走到这里时什么都没发(照旧「未确认(被驳回)」)。trail 上这一步记
outcome=rejected:运行收尾据此在 run.finished 上照实写「途经驳回」(runner._rejected_via)。审批模式写了「结果存为
变量」的照旧写 false(以前接了驳回边的审批就是这么写的);别的关卡这一步没有产出值,变量不写。"""
from app.core.artifact_store import put_json
run_ctx = ctx.run
payload = error.exit_payload()
nodes = run_ctx.spec.node_map()
to = [{"node_id": run_ctx.global_id(t), "label": nodes[t].title if t in nodes else t} for t in dict.fromkeys(targets)]
try:
artifact_id: str | None = await put_json(payload, kind="node_output", run_id=run_ctx.run_id,
node_id=run_ctx.global_id(node.id),
meta={"type": str(node.type), "attempt": attempt, "outcome": "rejected"})
except Exception: # noqa: BLE001 - 工件写失败不该毁掉运行本身
artifact_id = None
said = {"kind": error.kind, "decision": error.decision, "actor": error.actor, "note": error.note}
ctx.emit(EventType.NODE_FINISHED, duration_ms=elapsed, attempt=attempt,
preview=_preview({"nodes": {node.id: payload}}, node.id), artifact=artifact_id,
outcome="rejected", **said, to=to)
updates: dict[str, Any] = {"nodes": {node.id: payload}, "trail": [{
"node_id": node.id, "type": str(node.type), "duration_ms": elapsed, "attempt": attempt, "ts": time.time(),
"outcome": "rejected", "label": node.title, **said, "to": to}]}
var_name = str(node.config.get("assign_to") or "").strip()
if var_name and error.kind == "approve":
updates["vars"] = {var_name: False}
return updates
def _describe(error: BaseException | None) -> str:
"""错误消息。NodeError 的 message 本来就是写给人看的;别的异常翻成一句原因,
不带类型名和内部符号——界面上出现过「_make_query_tool.<locals>._run() got an
@@ -294,8 +344,13 @@ def _make_router(
所以真正的判断逻辑放在节点执行阶段,这里只查表。
"""
mapping: dict[str, list[str]] = {}
# 审批模式以外的关卡节点(接了驳回出口才走到这里)只有两条路:驳回出口,和其余的(普通出口 out)。正常结束时产出里
# 没有 __decision__(调用工具、沙箱代码、双盲复算),或者是补充输入、编辑稿件写的 approved,都落到 default
gate = node.type in GATE_TYPES and not approve_mode(spec, node)
for edge in spec.outgoing(node.id):
key = edge.sourceHandle or "default"
if gate:
key = REJECT_HANDLE if key == REJECT_HANDLE else "default"
mapping.setdefault(key, []).append(edge.target)
default_targets = mapping.get("default") or []
@@ -371,7 +426,7 @@ def compile_graph(spec: GraphSpec, run_ctx: RunContext) -> StateGraph:
handles = {e.sourceHandle for e in outgoing if e.sourceHandle}
needs_routing = node.type in ROUTING_TYPES or (
node.type == NodeType.HUMAN and handles & {"approved", "rejected"}
)
) or bool(reject_targets(spec, node))
if needs_routing:
route, path_map = _make_router(node, spec)
+59 -9
View File
@@ -7,7 +7,7 @@ from typing import Any
from langgraph.config import get_stream_writer
from app.core.events import EventType
from app.engine.schema import GraphNode, GraphSpec
from app.engine.schema import REJECT_HANDLE, GraphNode, GraphSpec
from app.engine.state import GraphState, template_context
from app.engine.expressions import render_deep, render_template
@@ -34,6 +34,35 @@ class RunContext:
agent_limits: dict[str, Any] | None = None
extra: dict[str, Any] = field(default_factory=dict)
@property
def prefix(self) -> str:
"""子工作流里的节点在这次运行里的 id 前缀(「子工作流节点 id/」,嵌套的一层层接上);最外层是空串。"""
return str(self.extra.get(PREFIX_KEY) or "")
def global_id(self, node_id: str) -> str:
"""这张图里的节点 id → 这次运行里的 id(事件、工件上记的那个):最外层原样,子工作流里加前缀。"""
return f"{self.prefix}{node_id}"
#: 子工作流里的节点 id 前缀(RunContext.extra 里的键,engine/nodes/multi.run_subgraph 放)
PREFIX_KEY = "node_prefix"
#: 父运行的事件流(RunContext.extra 里的键,同上)。子工作流在父节点里用 ainvoke 跑,LangGraph 不把它的 custom 事件交给
#: 父图的流(ainvoke 不开 custom 模式,get_stream_writer 拿到的是空的那个):子工作流里每一步以前在运行的事件里一条都
#: 没有,时间线看不到、封存也不含它查过的数。所以 run_subgraph 把父图那一刻的写入口交下来,子工作流的节点经它发
STREAM_KEY = "stream_writer"
def stream_writer(run: RunContext) -> Any:
"""往这次运行的事件流里写事件的入口:子工作流里是父运行交下来的那个,否则是 LangGraph 这一刻的。不在图执行上下文里
(单元测试直接调执行器)时为 None。"""
writer = run.extra.get(STREAM_KEY)
if writer is not None:
return writer
try:
return get_stream_writer()
except Exception: # noqa: BLE001 - 不在图执行上下文里
return None
@dataclass
class NodeContext:
@@ -51,10 +80,13 @@ class NodeContext:
runner 在另一端消费,转成落库的 RunEvent 并广播给前端 —— 画布上的节点高亮、
token 流、工具调用卡片全都来自这里。
子工作流里的节点经父运行交下来的写入口发(stream_writer),节点 id 带上前缀(RunContext.global_id):
「子工作流节点 id/节点 id」,嵌套的一层层接上。事件里别的字段(台账条目、口径卡上记的输入)照旧写这张图里的 id,
读的一方按事件的节点 id 认它在哪一层(api/evidence 的 _scoped)。
"""
try:
writer = get_stream_writer()
except Exception: # noqa: BLE001 - 不在图执行上下文里(比如单元测试)
writer = stream_writer(self.run)
if writer is None:
return
if str(event_type) == EventType.LLM_END and "unpriced" not in data:
from app.providers.catalog import unpriced_call
@@ -66,7 +98,7 @@ class NodeContext:
{
"__agentlab__": True,
"type": str(event_type),
"node_id": self.node.id,
"node_id": self.run.global_id(self.node.id),
"ts": time.time(),
"data": data,
}
@@ -121,18 +153,36 @@ class NodeRejected(NodeError):
是 NodeError 的子类:节点这一步照旧记 node.failed(时间线、实例进度按它收尾);但不重试、不被 on_error=continue
接住(engine/compiler._execute:那两项是给故障准备的,驳回被吞掉运行就以 succeeded 结束了)。原话(str)照旧写给人看,
Run.error 和以前一字不差。kind 见 REJECTION_KINDS;decision 是 reject 或 expired_reject(同待办的结论)。"""
Run.error 和以前一字不差。kind 见 REJECTION_KINDS;decision 是 reject 或 expired_reject(同待办的结论)。
节点在画布上接了「驳回」出口(REJECT_HANDLE,engine/schema.reject_targets)时,驳回不让运行结束:compiler 接住它,
这一步正常结束、产出 exit_payload()、沿驳回那条边往下走(docs/design/orchestration-round/00-总方案.md §3)。stop 为真
的除外:审批节点明说了「驳回即终止运行」,那条驳回边照旧走不到(以前就是这样),运行照旧收成被驳回。"""
def __init__(self, node_id: str, message: str, *, kind: str, decision: str = "reject",
actor: str | None = None, note: str = "") -> None:
actor: str | None = None, note: str = "", stop: bool = False) -> None:
super().__init__(node_id, message)
self.kind = kind
self.decision = decision
self.actor = actor
self.note = note
self.stop = stop
@classmethod
def of(cls, ctx: Any, message: str, *, kind: str, decision: Any) -> NodeRejected:
def of(cls, ctx: Any, message: str, *, kind: str, decision: Any, stop: bool = False) -> NodeRejected:
"""按节点上下文和读出来的审批结论(engine/approval.Decision)造一个:谁驳回的取 ctx.actor()。"""
return cls(ctx.node.id, message, kind=kind, decision="expired_reject" if decision.expired else "reject",
actor=ctx.actor(), note=decision.note or "")
actor=ctx.actor(), note=decision.note or "", stop=stop)
def exit_payload(self) -> dict[str, Any]:
"""走驳回出口时这一步的产出:{rejected, decision, actor, note, kind, text},加路由用的 __decision__。
text 是原话(「「付款」未确认(被驳回),没有发送」),下游的「通知」「退回修改」写 {{ nodes.<id>.text }} 就有一句
说得清的话;note 是驳回人写的备注。审批模式另带 approved=false:以前接了驳回边的审批节点产出就是
{approved: false, note},下游模板读 approved 的照旧读得到。"""
out: dict[str, Any] = {"rejected": True, "decision": self.decision, "actor": self.actor, "note": self.note,
"kind": self.kind, "text": str(self), "__decision__": REJECT_HANDLE}
if self.kind == "approve":
out["approved"] = False
return out
+36
View File
@@ -129,6 +129,7 @@ def lint_for_publish(spec: GraphSpec, *, level: str, checkers: Mapping[str, Any]
"(那里会保存取数快照)", code="governed.code_network", node_id=node.id, field="network")
_lint_evidence(spec, flag, strict=strict)
_lint_reject_exits(spec, flag)
_lint_sql(spec, flag, checkers)
_load_extra_lints()
for check in EXTRA_LINTS:
@@ -158,6 +159,41 @@ def publish_issues(spec: GraphSpec, *, level: str, checkers: Mapping[str, Any] |
return [*_not_repeated(validate_graph(spec).issues, gate, spec), *gate]
def _lint_reject_exits(spec: GraphSpec, flag: Callable[..., None]) -> None:
"""「驳回」出口那条路要能走到成果节点或者结束(一个不再往下连的节点)(总方案 §3):走不到的,驳回之后只能一直绕下去,
运行会在步数上限处中止。各级都报错——这不是受管才有的要求,任何一次驳回都会把运行拖到那里。
按图上的可达性认:从驳回出口连到的节点往下走,碰到成果节点或者没有出边的节点就算走得到。绕回关卡自己(「退回修改」:
改完再问一次)算走得到:再问一次还能批准、走普通出口。受管级里驳回路径上的出具照常判档、契约照常核对,不另立规矩。"""
from app.engine.schema import reject_targets
nodes = spec.node_map()
for gate in spec.nodes:
targets = [t for t in reject_targets(spec, gate) if t in nodes]
if not targets or _reaches_an_end(spec, targets):
continue
flag(f"{_who(gate)}的「驳回」出口接到{'、'.join(f'「{nodes[t].title}」' for t in dict.fromkeys(targets))}之后,"
"走不到任何成果节点或结束:驳回之后运行只能一直绕下去,会在步数上限处中止。请让驳回之后的那条路接到成果节点,"
"或者在一个不再往下连的节点结束",
code="reject_exit.no_end", node_id=gate.id, always=True)
def _reaches_an_end(spec: GraphSpec, start: list[str]) -> bool:
nodes = spec.node_map()
seen: set[str] = set()
todo = list(start)
while todo:
cur = todo.pop()
if cur in seen or cur not in nodes:
continue
seen.add(cur)
outgoing = [e.target for e in spec.outgoing(cur) if e.target in nodes]
if nodes[cur].type == NodeType.OUTPUT or not outgoing:
return True
todo.extend(outgoing)
return False
def _lint_sql(spec: GraphSpec, flag: Callable[..., None], checkers: Mapping[str, Any] | None) -> None:
"""调用工具节点里写死的 SQL 对照数据目录检查(data/sqlcheck.py)。
+8 -5
View File
@@ -25,7 +25,7 @@ from __future__ import annotations
from collections import defaultdict, deque
from statistics import median
from app.engine.schema import GraphNode, GraphSpec, NodeType, back_edges
from app.engine.schema import REJECT_HANDLE, GraphNode, GraphSpec, NodeType, back_edges, reject_targets
#: 画布节点的宽度。前端 NodeCard 的 `width: 238` 是写死的,这里必须跟着它——
#: 排版算出来的走廊是给连线用的,宽度估错了走廊就白留。
@@ -108,11 +108,12 @@ def _ranks(
return rank
def _handle_order(node: GraphNode) -> list[str]:
def _handle_order(node: GraphNode, spec: GraphSpec | None = None) -> list[str]:
"""节点出口在画布上从上到下的顺序。分支的 yes/no 就该是这个顺序。
前端 `sourceHandles()` 决定出口怎么画,这里决定它们怎么排。两份必须一致,
否则分支标签的上下关系会和连线对不上。
否则分支标签的上下关系会和连线对不上。关卡节点接了「驳回」出口的(engine/schema.reject_targets),
驳回排在普通出口下面;没接的只有一个出口,排不排都一样。
"""
cfg = node.config
if node.type == NodeType.BRANCH:
@@ -125,7 +126,9 @@ def _handle_order(node: GraphNode) -> list[str]:
if node.type == NodeType.LOOP:
return ["body", "done"]
if node.type == NodeType.HUMAN and cfg.get("mode", "approve") == "approve":
return ["approved", "rejected"]
return ["approved", REJECT_HANDLE]
if spec is not None and reject_targets(spec, node):
return ["out", REJECT_HANDLE]
return ["out"]
@@ -225,7 +228,7 @@ def _apply_handle_order(
outgoing[e.source].append(e)
for node in spec.nodes:
handles = _handle_order(node)
handles = _handle_order(node, spec)
if len(handles) < 2 or node.id not in nodes:
continue
outs = outgoing.get(node.id, [])
+2 -2
View File
@@ -1379,8 +1379,8 @@ def _merge(per_input: list[tuple[dict[str, Any], dict[str, Any], dict[str, Any]]
def _choices(ctx: NodeContext, response: Any, rows: list[dict[str, Any]]) -> tuple[dict[str, str], str]:
"""审核人的回复 → ({指标 id: a | b | neither}, 备注)。回复的 value 是 {choices, note};某个指标没选、选了认不出的
不进 choices:照实记成「没有作出选择」,不替人说「两边都不对」,也不替人认可任何一边(缺口照样记、出具照样降档)。
通用的输入卡送来的是一句话,所有指标都按没选记。明确驳回(approved 为否)的按人工驳回让节点失败,和人工审批节点的
填写模式一样:这一步没有驳回的出口。"""
通用的输入卡送来的是一句话,所有指标都按没选记。明确驳回(approved 为否)的抛 NodeRejected,和人工审批节点的
填写模式一样:画布上接了「驳回」出口的沿它往下走(engine/compiler),没接的运行收成被驳回。"""
decision = read_decision(response)
if isinstance(response, dict) and decision.rejected:
raise NodeRejected.of(ctx, f"人工驳回:{decision.note or '未说明原因'}", kind="dual_check", decision=decision)
+10 -4
View File
@@ -10,6 +10,7 @@ from app.db.base import SessionLocal
from app.engine.approval import read_decision
from app.engine.context import NodeContext, NodeError, NodeRejected
from app.engine.replay import ask, once
from app.engine.schema import reject_targets
from app.engine.state import GraphState, merge_usage, message_text, template_context
from app.providers import catalog
from app.providers.factory import ModelSpec, get_chat_model
@@ -51,15 +52,20 @@ async def run_human(state: GraphState, ctx: NodeContext) -> dict[str, Any]:
"note": decision.note,
"__decision__": "approved" if approved else "rejected",
}
if not approved and ctx.cfg("stop_on_reject", False):
raise NodeRejected.of(ctx, f"人工驳回:{result['note'] or '未说明原因'}", kind="approve", decision=decision)
# 驳回即终止:照旧收成被驳回,接没接驳回边都一样(明说了终止,那条边以前就走不到;stop=True,compiler 不接)。
# 画布上接了「驳回」出口的:同样交给 NodeRejected,由 compiler 接住、这一步正常结束、沿驳回边往下走,产出和别的
# 关卡同一种形状(engine/schema.reject_targets)。两样都没有的照旧按 __decision__ 路由(没有驳回边就结束在这里)
stop = bool(ctx.cfg("stop_on_reject", False))
if not approved and (stop or reject_targets(ctx.run.spec, ctx.node)):
raise NodeRejected.of(ctx, f"人工驳回:{result['note'] or '未说明原因'}", kind="approve", decision=decision,
stop=stop)
else: # edit / input
# 驳回在这两种模式下以前是个摆设:__decision__ 硬编码成 approved,
# approved 字段看都不看。界面上按钮在、toast 说"已驳回",运行却照常
# 往下走——比没有这个按钮更糟。
#
# 这两种模式在图上只有一个 out 出口(没有 rejected 那条边),所以驳回
# 的正确语义是终止运行,而不是当作通过继续。缺省仍是通过:只传 value
# 这两种模式在图上本来只有一个 out 出口,所以驳回的语义是终止运行,而不是当作通过继续;
# 画布上接了「驳回」出口的,compiler 接住 NodeRejected、沿驳回边往下走。缺省仍是通过:只传 value
# 不带 approved 的老调用方行为不变。
#
# 只有结构体里明说了"不"才算驳回:这两种模式下裸字符串就是内容本身,
+3 -2
View File
@@ -302,8 +302,9 @@ async def _run_write(state: GraphState, ctx: NodeContext, name: str, args: dict[
await once(ctx, EventType.HUMAN_RESOLVED, tool=name, approved=decision.approved, note=decision.note,
actor=ctx.actor(), payload_hash=confirmed)
if not decision.approved:
# 驳回是人的决定,不是故障:运行到这里结束(没有可走的出口),收成 cancelled + end_reason=rejected
# (NodeRejected),说法写成「未确认(被驳回)」,实例页、通知按同一个结论说(apps/resolve.instance_state)
# 驳回是人的决定,不是故障:抛 NodeRejected,说法写成「未确认(被驳回)」,实例页、通知按同一个结论说
# (apps/resolve.instance_state)。抛在发送之前:画布上接了「驳回」出口的沿它往下走(engine/compiler),什么都
# 没发;没接的运行到这里结束,收成 cancelled + end_reason=rejected
raise NodeRejected.of(ctx, f"「{ctx.node.title}」未确认(被驳回),没有发送"
+ (f":{decision.note}" if decision.note else ""),
kind="action_confirm", decision=decision)
+12 -2
View File
@@ -1039,13 +1039,13 @@ class RunManager:
# 切断的半截答案当成完整结论落了库
clipped, truncated = _clip(output)
data: dict[str, Any] = {"output": clipped, "usage": usage,
"duration_ms": timing["active_ms"], "timing": timing}
"duration_ms": timing["active_ms"], "timing": timing, **_rejected_via(state)}
if truncated:
data["output_truncated"] = True
event = self._event(run_id, EventType.RUN_FINISHED, data=data)
elif terminal is not None:
kind, data = terminal
event = self._event(run_id, kind, data={**data, "timing": timing})
event = self._event(run_id, kind, data={**data, "timing": timing, **_rejected_via(state)})
if run:
run.status = status
@@ -1346,6 +1346,16 @@ def _trust_event(tool_trust: dict[str, str] | None) -> Any:
return "formal" if tool_trust.get(FORMAL_MARK) else snapshot_levels(tool_trust)
def _rejected_via(state: dict[str, Any]) -> dict[str, Any]:
"""这次运行途经的驳回出口(engine/compiler._rejected_exit 记在 trail 上的 outcome=rejected):{rejected_via: [{node_id,
label, kind, decision, actor, note, to}]},按先后。终态事件带上它,运行照它的路径结束(成功结束也一样)照实说「途经
驳回」;没有途经的不带这个键,终态事件和以前一字不差。读的是收尾时的状态:节点出错、被驳回结束的那几种收尾拿不到
状态(final_state 为空),不带;子工作流里的驳回出口不在这里(它的 trail 是子工作流自己的状态)。"""
via = [{k: t.get(k) for k in ("node_id", "label", "kind", "decision", "actor", "note", "to")}
for t in state.get("trail") or [] if isinstance(t, dict) and t.get("outcome") == "rejected"]
return {"rejected_via": via} if via else {}
def rejected_data(exc: NodeRejected, spec: GraphSpec) -> dict[str, Any]:
"""被驳回的 run.cancelled 带什么:原因(rejected)、在哪一步(节点 id 和图上的名字)、哪种关卡、结论(驳回 / 超时
驳回)、谁、备注。进封存:谁在哪一步驳回、为什么,事后查得到。"""
+44
View File
@@ -144,6 +144,37 @@ class GraphSpec(BaseModel):
return [n for n in self.nodes if not self.outgoing(n.id)]
# --------------------------------------------------------------------------
# 驳回出口(docs/design/orchestration-round/00-总方案.md §3)
# --------------------------------------------------------------------------
#: 会被人驳回、能接「驳回」出口的节点:人工节点(审批、补充输入、编辑稿件)、调用工具(工具调用审批、写入前的动作确认)、
#: 沙箱代码(代码执行审批)、双盲复算(裁决)。和 context.REJECTION_KINDS 的六种关卡一一对得上
GATE_TYPES = frozenset({NodeType.HUMAN, NodeType.TOOL, NodeType.CODE, NodeType.DUAL_CHECK})
#: 「驳回」出口的 sourceHandle(同 context.REJECT_HANDLE)
REJECT_HANDLE = "rejected"
def approve_mode(spec: GraphSpec, node: GraphNode) -> bool:
"""人工节点是不是审批模式(和 NodeContext.cfg 同一个规则:节点上没写取图级 defaults,都没写是审批)。审批模式本来就有
「批准」「驳回」两个出口,按 __decision__ 路由;别的关卡只有一个普通出口,接了驳回出口才多一个。"""
if node.type != NodeType.HUMAN:
return False
mode = node.config.get("mode")
return (spec.defaults.get("mode") if mode in (None, "") else mode) in (None, "", "approve")
def reject_targets(spec: GraphSpec, node: GraphNode) -> list[str]:
"""这个关卡节点「驳回」出口连到的节点(按连线的先后);不是关卡、没接驳回出口的为空。
接了:驳回(含超时驳回)时这一步正常结束、沿这几条边往下走(engine/compiler);没接:驳回让运行结束(cancelled +
end_reason=rejected),和以前一字不差。审批模式另有一条老规矩:没设「驳回即终止」时,驳回本来就按 __decision__ 走
驳回边(没接就结束在这里、运行成功),那一条照旧。"""
if node.type not in GATE_TYPES:
return []
return [e.target for e in spec.outgoing(node.id) if e.sourceHandle == REJECT_HANDLE]
# --------------------------------------------------------------------------
# 校验
# --------------------------------------------------------------------------
@@ -869,6 +900,14 @@ def validate_graph(spec: GraphSpec) -> ValidationResult:
result.add(f"连线的起点节点「{edge.source}」不存在", edge_id=edge.id)
if edge.target not in nodes:
result.add(f"连线的终点节点「{edge.target}」不存在", edge_id=edge.id)
source = nodes.get(edge.source)
if edge.sourceHandle == REJECT_HANDLE and source is not None \
and source.type not in GATE_TYPES and source.type != NodeType.BRANCH:
# 「驳回」出口只在会被人驳回的节点上有意义:别的节点上这条线不会被路由,每次都会走(条件分支的 case 标识
# 可以叫 rejected,那是分支自己的出口)
result.add(f"「{source.title}」不会被人驳回,不能接「驳回」出口:只有人工节点(审批、补充输入、编辑稿件)、"
"调用工具(工具调用审批、动作确认)、沙箱代码(代码执行审批)、双盲复算能接。请把这条连线改接到"
"节点的普通出口", node_id=source.id, edge_id=edge.id, code="graph.reject_exit_invalid")
if not spec.entry_nodes():
result.add("找不到起始节点:每个节点都有上游连线,工作流中存在环路且没有起点")
@@ -911,6 +950,11 @@ def validate_graph(spec: GraphSpec) -> ValidationResult:
for code, message, field in human_issues(node):
result.add(message, node_id=node.id, field=field, code=code)
if cfg.get("stop_on_reject") and approve_mode(spec, node) and reject_targets(spec, node):
# 驳回即终止优先(以前就是这样):驳回出口那条线走不到。两样都写着,说明有一样不是作者的本意
result.add("这个审批设了「驳回即终止运行」,「驳回」出口的连线不会走到:驳回时运行直接结束。"
"要让驳回之后走那条路,请关掉「驳回即终止运行」", level="warning", node_id=node.id,
field="stop_on_reject", code="human.stop_on_reject_exit")
elif node.type == NodeType.SUBGRAPH:
if not cfg.get("workflow_id"):
result.add("「子工作流」节点还没有选择要嵌套的工作流", node_id=node.id,