feat(workflow): 增加会话级多智能体任务规划运行能力
提交范围聚焦于工作流编排新增:新增 workflow_planning 路由与前后端运行入口(workflow_planning.py、workflow_proposal_planner.py、workflow_deep_research_adapter.py),支持基于会话的提案-规划-执行流程,满足任务驱动式多智能体协作。 完成网关层运行时适配:扩展 workflow_resource_checks、workflow_executor、workflow_runs、workflow_agent_runner 与依赖注入,新增/更新配置(config.yaml、workflow_config),并补充 lead_agent 路径与节点实现,确保 Planner 与普通工作流运行态衔接一致。 补齐持久化与建模:新增 workflow_planning 持久化模块与 MySQL migration(20260831_01_workflow_planning_sessions),注册 SQL 与模型、内存 store,并扩展错误/表达式/validator/节点语义以承载新会话态输入输出。 增强文档与测试:新增会话式多智能体编排中文说明、更新开发文档与 AGENTS 指南、补充 workflow_engine/workflow_runs 回归测试,提高新路径的行为可验证性;同时留存 seed 资产(workflow-planner)便于一体化部署。
This commit is contained in:
1 parent
ac92f29db1
commit
1706a24182
39 files changed
+4896
-81
No files matched your search
@@ -3,6 +3,7 @@
|
||||
from __future__ import annotations
|
||||
|
||||
import asyncio
|
||||
import hashlib
|
||||
import json
|
||||
import logging
|
||||
from datetime import UTC, datetime
|
||||
@@ -14,12 +15,19 @@ from pydantic import BaseModel, Field
|
||||
|
||||
from app.gateway.deps import get_current_user, get_optional_user_from_request
|
||||
from app.gateway.workflow_audit import audit_workflow
|
||||
from app.gateway.workflow_resource_checks import build_resource_catalog, make_resource_checker
|
||||
from deerflow.config.app_config import get_app_config
|
||||
from deerflow.persistence.workflow_events.base import WorkflowEventStore
|
||||
from deerflow.persistence.workflow_planning import (
|
||||
WorkflowPlanningConflictError,
|
||||
WorkflowPlanningProposalNotFoundError,
|
||||
WorkflowPlanningStore,
|
||||
)
|
||||
from deerflow.persistence.workflow_runs.base import WorkflowRunStore
|
||||
from deerflow.workflows.runtime.sink import envelope_from_row
|
||||
from deerflow.workflows.schema_validation import schema_issues
|
||||
from deerflow.workflows.schemas import WorkflowGraph
|
||||
from deerflow.workflows.validator import validate_workflow_graph
|
||||
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
@@ -32,6 +40,11 @@ _DB_POLL_SECONDS = 0.8
|
||||
_LIVE_WAIT_SECONDS = 0.25
|
||||
_HEARTBEAT_SECONDS = 15.0
|
||||
_STREAM_DEADLINE_SECONDS = 60 * 60
|
||||
# Send one harmless, sufficiently sized comment as soon as the connection is
|
||||
# accepted. This prevents a proxy from withholding the first small durable
|
||||
# event until the run has already produced a batch of output. It is an SSE
|
||||
# comment, so it does not affect the persisted event sequence or UI reducer.
|
||||
_SSE_FLUSH_PADDING = " " * 2_048
|
||||
|
||||
|
||||
class StartRunBody(BaseModel):
|
||||
@@ -40,6 +53,13 @@ class StartRunBody(BaseModel):
|
||||
# 独立 Coze 工作流页早期使用 input/target;保留兼容入口,内部仍只使用 inputs。
|
||||
input: dict[str, Any] | None = None
|
||||
target: str | None = None
|
||||
# 对话面板的显式定向任务:不是打断既有 run,而是从当前图中选取一个已
|
||||
# 绑定的 Agent,投影成可审计的 start → agent → output 新运行。
|
||||
target_agent_id: str | None = Field(default=None, alias="targetAgentId", max_length=191)
|
||||
# 规划会话中的已选候选图。二者必须同时给出;正式执行只读取服务端持久化
|
||||
# 的 proposal 快照,永不接受浏览器直接塞入的临时 graph。
|
||||
planning_session_id: str | None = Field(default=None, alias="planningSessionId", max_length=64)
|
||||
proposal_id: str | None = Field(default=None, alias="proposalId", max_length=64)
|
||||
idempotency_key: str | None = Field(default=None, alias="idempotencyKey", max_length=128)
|
||||
|
||||
model_config = {"populate_by_name": True}
|
||||
@@ -63,6 +83,16 @@ class ResumeRunBody(BaseModel):
|
||||
return self.values if self.values or self.payload is None else self.payload
|
||||
|
||||
|
||||
class FeedbackRunBody(BaseModel):
|
||||
"""A targeted revision request for one completed Agent/Skill node."""
|
||||
|
||||
node_id: str = Field(alias="nodeId", min_length=1, max_length=128)
|
||||
message: str = Field(min_length=1, max_length=8_000)
|
||||
idempotency_key: str | None = Field(default=None, alias="idempotencyKey", max_length=128)
|
||||
|
||||
model_config = {"populate_by_name": True}
|
||||
|
||||
|
||||
# ── shared plumbing ─────────────────────────────────────────────────────
|
||||
|
||||
|
||||
@@ -96,6 +126,13 @@ def _definitions(request: Request):
|
||||
return store
|
||||
|
||||
|
||||
def _planning(request: Request) -> WorkflowPlanningStore:
|
||||
store = getattr(request.app.state, "workflow_planning_store", None)
|
||||
if store is None:
|
||||
raise HTTPException(status_code=503, detail="Workflow planning store not available")
|
||||
return store
|
||||
|
||||
|
||||
def _nudge(request: Request) -> None:
|
||||
dispatcher = getattr(request.app.state, "workflow_dispatcher", None)
|
||||
if dispatcher is not None:
|
||||
@@ -119,6 +156,7 @@ async def _authorized_run(request: Request, run_id: str) -> dict[str, Any]:
|
||||
|
||||
def _public_run(run: dict[str, Any]) -> dict[str, Any]:
|
||||
"""Run view for HTTP clients: no lease internals, no resume token."""
|
||||
context = run.get("context") or {}
|
||||
return {
|
||||
"id": run["id"],
|
||||
"runId": run["id"],
|
||||
@@ -139,9 +177,155 @@ def _public_run(run: dict[str, Any]) -> dict[str, Any]:
|
||||
# The run row's counter holds the last seq handed out by the event log
|
||||
# (the event store bumps it in the insert transaction); 0 = no events.
|
||||
"lastSeq": int(run.get("next_event_seq") or 0),
|
||||
"executionMode": context.get("executionMode") or "workflow",
|
||||
"targetAgentId": context.get("targetAgentId"),
|
||||
"targetAgentName": context.get("targetAgentName"),
|
||||
"planningSessionId": context.get("planningSessionId"),
|
||||
"proposalId": context.get("proposalId"),
|
||||
"revisionOfRunId": context.get("revisionOfRunId"),
|
||||
"feedback": context.get("feedback"),
|
||||
}
|
||||
|
||||
|
||||
async def _run_validation_issues(
|
||||
request: Request,
|
||||
*,
|
||||
workflow_id: str,
|
||||
graph: WorkflowGraph,
|
||||
user_id: str,
|
||||
) -> list[Any]:
|
||||
"""Validate the exact graph snapshot about to enter the run queue.
|
||||
|
||||
Studio validation is advisory while an author is editing. Starting a run
|
||||
is the enforcement boundary: do not queue an unbound SQL/HTTP/subworkflow
|
||||
node only to fail it later after a dispatcher lease has been acquired.
|
||||
"""
|
||||
config = _cfg()
|
||||
catalog = await build_resource_catalog(request, user_id=user_id)
|
||||
checker = make_resource_checker(
|
||||
catalog,
|
||||
config=config,
|
||||
current_workflow_id=workflow_id,
|
||||
)
|
||||
return validate_workflow_graph(
|
||||
graph,
|
||||
resource_checker=checker,
|
||||
system_max_steps=config.max_steps,
|
||||
system_max_loop_iterations=config.max_loop_iterations,
|
||||
system_max_parallelism=config.max_parallelism,
|
||||
)
|
||||
|
||||
|
||||
def _agent_task_graph(graph: WorkflowGraph, target_agent_id: str) -> WorkflowGraph:
|
||||
"""Build an explicit, durable one-agent task graph from a canvas graph.
|
||||
|
||||
A chat composer cannot safely "message" a running node: that loses DAG
|
||||
ordering, cancellation, event persistence and resource checks. Instead a
|
||||
target selection starts a separate run whose graph is a small projection of
|
||||
one *already bound* agent node. The original node id is preserved, so its
|
||||
streamed output still highlights the corresponding canvas card.
|
||||
"""
|
||||
matches = [
|
||||
node
|
||||
for node in graph.nodes
|
||||
if node.type == "agent"
|
||||
and str(node.config.get("agentId") or node.config.get("agent_id") or "")
|
||||
== target_agent_id
|
||||
]
|
||||
if not matches:
|
||||
raise HTTPException(
|
||||
status_code=400,
|
||||
detail={
|
||||
"code": "WORKFLOW_AGENT_TARGET_NOT_BOUND",
|
||||
"message": "指定的智能体尚未绑定到当前画布,请先从节点资源拖入该智能体",
|
||||
"details": {"targetAgentId": target_agent_id},
|
||||
},
|
||||
)
|
||||
if len(matches) > 1:
|
||||
raise HTTPException(
|
||||
status_code=400,
|
||||
detail={
|
||||
"code": "WORKFLOW_AGENT_TARGET_AMBIGUOUS",
|
||||
"message": "该智能体在画布中绑定了多个节点,请在画布中保留一个定向任务节点后重试",
|
||||
"details": {"targetAgentId": target_agent_id, "nodeIds": [node.id for node in matches]},
|
||||
},
|
||||
)
|
||||
|
||||
agent = matches[0]
|
||||
config = dict(agent.config)
|
||||
raw_bindings = config.get("inputBindings") or config.get("input_bindings")
|
||||
bindings = dict(raw_bindings) if isinstance(raw_bindings, dict) else {}
|
||||
# Regardless of the authoring form, the chat task itself must be visible to
|
||||
# the selected agent. Keep every existing binding intact for its role.
|
||||
bindings["workflowInput"] = "{{ inputs }}"
|
||||
config["inputBindings"] = bindings
|
||||
config["agentName"] = str(config.get("agentName") or agent.name or target_agent_id)
|
||||
|
||||
return WorkflowGraph.model_validate(
|
||||
{
|
||||
"schemaVersion": "1.0",
|
||||
"id": graph.id,
|
||||
"name": f"{graph.name or graph.id} · {agent.name or target_agent_id}",
|
||||
"inputSchema": {
|
||||
"type": "object",
|
||||
"required": ["query"],
|
||||
"properties": {"query": {"type": "string", "minLength": 1}},
|
||||
},
|
||||
"outputSchema": {"type": "object", "properties": {"text": {"type": "string"}}},
|
||||
"nodes": [
|
||||
{"id": "__agent_task_start__", "type": "start", "name": "定向任务开始"},
|
||||
{"id": agent.id, "type": "agent", "name": agent.name, "config": config},
|
||||
{
|
||||
"id": "__agent_task_output__",
|
||||
"type": "output",
|
||||
"name": "定向任务输出",
|
||||
"config": {"mapping": {"text": f"{{{{ nodes.{agent.id}.data.text }}}}"}},
|
||||
},
|
||||
],
|
||||
"edges": [
|
||||
{"id": "__agent_task_start_to_agent__", "source": "__agent_task_start__", "target": agent.id},
|
||||
{"id": "__agent_task_agent_to_output__", "source": agent.id, "target": "__agent_task_output__"},
|
||||
],
|
||||
}
|
||||
)
|
||||
|
||||
|
||||
async def _run_graph_snapshot(request: Request, run: dict[str, Any]) -> WorkflowGraph:
|
||||
"""Return the immutable graph that actually produced ``run``.
|
||||
|
||||
Draft, planned, and targeted-agent runs keep their graph in ``context``;
|
||||
a feedback revision must use that snapshot rather than today's editable
|
||||
canvas or a newer published version.
|
||||
"""
|
||||
raw = (run.get("context") or {}).get("draftGraph")
|
||||
if raw is None:
|
||||
version = await _definitions(request).get_version(run["workflow_version_id"])
|
||||
raw = (version or {}).get("graph")
|
||||
try:
|
||||
return WorkflowGraph.model_validate(raw or {})
|
||||
except Exception as exc: # noqa: BLE001 - persisted malformed state must not be rerun
|
||||
raise HTTPException(
|
||||
status_code=409,
|
||||
detail={"code": "WORKFLOW_VERSION_NOT_FOUND", "message": "原运行的执行图不可恢复"},
|
||||
) from exc
|
||||
|
||||
|
||||
def _downstream_nodes(graph: WorkflowGraph, start_node_id: str) -> set[str]:
|
||||
"""Return a node plus every ordinary downstream consumer of its output."""
|
||||
adjacency: dict[str, list[str]] = {}
|
||||
for edge in graph.edges:
|
||||
adjacency.setdefault(edge.source, []).append(edge.target)
|
||||
affected: set[str] = set()
|
||||
pending = [start_node_id]
|
||||
while pending:
|
||||
current = pending.pop()
|
||||
if current in affected:
|
||||
continue
|
||||
affected.add(current)
|
||||
pending.extend(adjacency.get(current) or [])
|
||||
return affected
|
||||
|
||||
|
||||
# ── start / list / get / cancel / resume ────────────────────────────────
|
||||
|
||||
|
||||
@@ -151,6 +335,44 @@ async def start_run(request: Request, workflow_id: str, body: StartRunBody) -> d
|
||||
user_id = await get_current_user(request)
|
||||
definitions = _definitions(request)
|
||||
is_draft_run = str(body.target or "").strip().lower() == "draft"
|
||||
planning_session_id = str(body.planning_session_id or "").strip()
|
||||
proposal_id = str(body.proposal_id or "").strip()
|
||||
if bool(planning_session_id) != bool(proposal_id):
|
||||
raise HTTPException(
|
||||
status_code=400,
|
||||
detail={"code": "WORKFLOW_PLANNING_INVALID", "message": "planningSessionId 和 proposalId 必须同时提供"},
|
||||
)
|
||||
is_planning_run = bool(planning_session_id)
|
||||
if is_planning_run and body.target_agent_id:
|
||||
raise HTTPException(
|
||||
status_code=400,
|
||||
detail={"code": "WORKFLOW_PLANNING_INVALID", "message": "确认候选流程时不能同时指定单个智能体"},
|
||||
)
|
||||
|
||||
planning_session: dict[str, Any] | None = None
|
||||
planning_graph_raw: dict[str, Any] | None = None
|
||||
if is_planning_run:
|
||||
planning_session = await _planning(request).get_session(planning_session_id)
|
||||
if planning_session is None:
|
||||
raise HTTPException(status_code=404, detail={"code": "WORKFLOW_PLANNING_NOT_FOUND", "message": "规划会话不存在"})
|
||||
if planning_session.get("workflow_id") != workflow_id:
|
||||
raise HTTPException(status_code=400, detail={"code": "WORKFLOW_PLANNING_INVALID", "message": "候选流程不属于当前工作流"})
|
||||
if planning_session.get("owner_id") != user_id and not await _is_admin(request):
|
||||
raise HTTPException(status_code=403, detail={"code": "WORKFLOW_FORBIDDEN", "message": "无权确认该候选流程"})
|
||||
selected = next((item for item in planning_session.get("proposals") or [] if item.get("id") == proposal_id), None)
|
||||
if selected is None:
|
||||
raise HTTPException(status_code=404, detail={"code": "WORKFLOW_PROPOSAL_NOT_FOUND", "message": "候选流程不存在"})
|
||||
if planning_session.get("status") == "confirmed":
|
||||
if planning_session.get("selected_proposal_id") != proposal_id:
|
||||
raise HTTPException(status_code=409, detail={"code": "WORKFLOW_PLANNING_CONFLICT", "message": "规划会话已确认了另一条候选流程"})
|
||||
existing_run_id = planning_session.get("confirmed_run_id")
|
||||
existing_run = await _runs(request).get_run(str(existing_run_id)) if existing_run_id else None
|
||||
if existing_run is not None:
|
||||
return {**_public_run(existing_run), "created": False}
|
||||
raise HTTPException(status_code=409, detail={"code": "WORKFLOW_PLANNING_CONFLICT", "message": "规划会话已确认,请刷新后重试"})
|
||||
if planning_session.get("selected_proposal_id") != proposal_id:
|
||||
raise HTTPException(status_code=409, detail={"code": "WORKFLOW_PLANNING_CONFLICT", "message": "请先选择该候选流程"})
|
||||
planning_graph_raw = selected.get("graph") if isinstance(selected.get("graph"), dict) else {}
|
||||
|
||||
if is_draft_run:
|
||||
# Test-run semantics: execute the CURRENT draft graph (what the canvas
|
||||
@@ -178,7 +400,12 @@ async def start_run(request: Request, workflow_id: str, body: StartRunBody) -> d
|
||||
)
|
||||
|
||||
version_id = body.version_id
|
||||
if not version_id and not is_draft_run:
|
||||
version: dict[str, Any] | None = None
|
||||
if is_planning_run:
|
||||
# The graph itself is frozen into run.context; this version label is an
|
||||
# audit marker and deliberately has no workflow_versions row.
|
||||
version_id = f"plan:{planning_session_id}"
|
||||
elif not version_id and not is_draft_run:
|
||||
versions = await definitions.list_versions(workflow_id)
|
||||
if not versions:
|
||||
raise HTTPException(
|
||||
@@ -188,13 +415,48 @@ async def start_run(request: Request, workflow_id: str, body: StartRunBody) -> d
|
||||
version_id = versions[0]["id"]
|
||||
if is_draft_run:
|
||||
version_id = "draft"
|
||||
else:
|
||||
elif not is_planning_run:
|
||||
version = await definitions.get_version(version_id)
|
||||
if version is None or version.get("workflow_id") != workflow_id:
|
||||
raise HTTPException(status_code=404, detail={"code": "WORKFLOW_VERSION_NOT_FOUND", "message": "版本不存在"})
|
||||
|
||||
graph = WorkflowGraph.model_validate(draft_graph_raw if is_draft_run else (version.get("graph") or {}))
|
||||
try:
|
||||
graph = WorkflowGraph.model_validate(
|
||||
planning_graph_raw if is_planning_run else (draft_graph_raw if is_draft_run else (version.get("graph") or {})),
|
||||
)
|
||||
except Exception as exc: # noqa: BLE001 - malformed persisted graph must not reach a worker
|
||||
raise HTTPException(
|
||||
status_code=400,
|
||||
detail={
|
||||
"code": "WORKFLOW_SCHEMA_INVALID",
|
||||
"message": f"执行图不符合 WorkflowGraph v1.0: {exc}",
|
||||
},
|
||||
) from exc
|
||||
|
||||
target_agent_id = str(body.target_agent_id or "").strip()
|
||||
if target_agent_id:
|
||||
graph = _agent_task_graph(graph, target_agent_id)
|
||||
|
||||
issues = await _run_validation_issues(
|
||||
request,
|
||||
workflow_id=workflow_id,
|
||||
graph=graph,
|
||||
user_id=user_id,
|
||||
)
|
||||
if issues:
|
||||
first = issues[0].model_dump(by_alias=True)
|
||||
raise HTTPException(
|
||||
status_code=400,
|
||||
detail={
|
||||
"code": first.get("code") or "WORKFLOW_SCHEMA_INVALID",
|
||||
"message": f"当前执行图不可运行:{first.get('message') or '请检查节点配置'}",
|
||||
"nodeId": first.get("nodeId"),
|
||||
"details": {"issues": [issue.model_dump(by_alias=True) for issue in issues]},
|
||||
},
|
||||
)
|
||||
inputs = body.resolved_inputs()
|
||||
if is_planning_run and not inputs and planning_session is not None:
|
||||
inputs = {"query": planning_session["query"]}
|
||||
missing = [key for key in (graph.input_schema.get("required") or []) if inputs.get(str(key)) in (None, "")]
|
||||
if missing:
|
||||
raise HTTPException(
|
||||
@@ -232,10 +494,29 @@ async def start_run(request: Request, workflow_id: str, body: StartRunBody) -> d
|
||||
# Scope the idempotency key per workflow so two workflows can share a client key.
|
||||
key = f"{workflow_id}:{body.idempotency_key}" if body.idempotency_key else None
|
||||
context: dict[str, Any] = {"depth": 0}
|
||||
if is_draft_run:
|
||||
if is_draft_run or target_agent_id or is_planning_run:
|
||||
# The draft snapshot rides with the run; the executor prefers it over
|
||||
# the published version. Execution graph only — never the canvas doc.
|
||||
context["draftGraph"] = draft_graph_raw
|
||||
# A directed agent task uses the same durable snapshot mechanism even
|
||||
# when the source graph originated from a published version.
|
||||
context["draftGraph"] = graph.model_dump(by_alias=True)
|
||||
if target_agent_id:
|
||||
target_node = next(node for node in graph.nodes if node.type == "agent")
|
||||
context.update(
|
||||
{
|
||||
"executionMode": "agent_task",
|
||||
"targetAgentId": target_agent_id,
|
||||
"targetAgentName": target_node.name or target_agent_id,
|
||||
}
|
||||
)
|
||||
if is_planning_run:
|
||||
context.update(
|
||||
{
|
||||
"executionMode": "planned_workflow",
|
||||
"planningSessionId": planning_session_id,
|
||||
"proposalId": proposal_id,
|
||||
}
|
||||
)
|
||||
run, created = await runs.create_run(
|
||||
{
|
||||
"workflow_id": workflow_id,
|
||||
@@ -247,12 +528,29 @@ async def start_run(request: Request, workflow_id: str, body: StartRunBody) -> d
|
||||
}
|
||||
)
|
||||
if created:
|
||||
if is_planning_run:
|
||||
try:
|
||||
await _planning(request).confirm_proposal(
|
||||
planning_session_id,
|
||||
proposal_id,
|
||||
run_id=run["id"],
|
||||
)
|
||||
except WorkflowPlanningProposalNotFoundError as exc:
|
||||
await runs.finalize_cancel(run["id"])
|
||||
raise HTTPException(status_code=409, detail={"code": "WORKFLOW_PLANNING_CONFLICT", "message": "候选流程已失效,请重新选择"}) from exc
|
||||
except WorkflowPlanningConflictError as exc:
|
||||
await runs.finalize_cancel(run["id"])
|
||||
raise HTTPException(status_code=409, detail={"code": "WORKFLOW_PLANNING_CONFLICT", "message": str(exc)}) from exc
|
||||
await _events(request).append(
|
||||
run_id=run["id"],
|
||||
workflow_id=workflow_id,
|
||||
version_id=version_id,
|
||||
event_type="run.created",
|
||||
payload={"inputs": inputs},
|
||||
payload={
|
||||
"inputs": inputs,
|
||||
**({"executionMode": "agent_task", "targetAgentId": target_agent_id} if target_agent_id else {}),
|
||||
**({"executionMode": "planned_workflow", "planningSessionId": planning_session_id, "proposalId": proposal_id} if is_planning_run else {}),
|
||||
},
|
||||
)
|
||||
audit_workflow("run.start", user_id=user_id, workflowId=workflow_id, runId=run["id"], versionId=version_id)
|
||||
_nudge(request)
|
||||
@@ -578,6 +876,208 @@ async def retry_run(request: Request, run_id: str) -> dict[str, Any]:
|
||||
return {**_public_run(new_run), "created": True}
|
||||
|
||||
|
||||
@router.post("/runs/{run_id}/feedback", status_code=201)
|
||||
async def revise_run_from_node_feedback(
|
||||
request: Request,
|
||||
run_id: str,
|
||||
body: FeedbackRunBody,
|
||||
) -> dict[str, Any]:
|
||||
"""Create an auditable local rerun from feedback on one Agent/Skill node.
|
||||
|
||||
Completed snapshots in the original run are immutable. Instead of erasing
|
||||
them, this creates a revision run, copies completed nodes outside the
|
||||
target's downstream impact set, and re-executes the target plus its
|
||||
consumers. The feedback is injected only into that target's prompt through
|
||||
``RunContext.env.nodeFeedback``. This first public slice deliberately
|
||||
accepts terminal, non-loop graphs only; a live run must be paused with a
|
||||
normal ``human_input`` card or explicitly cancelled before revision so two
|
||||
workers can never produce competing side effects.
|
||||
"""
|
||||
_require_enabled()
|
||||
run = await _authorized_run(request, run_id)
|
||||
if run["status"] not in _TERMINAL_STATUSES:
|
||||
raise HTTPException(
|
||||
status_code=409,
|
||||
detail={
|
||||
"code": "WORKFLOW_RUN_CONFLICT",
|
||||
"message": "运行仍在执行;请先使用人工协助卡补充信息,或停止后再发起局部重跑",
|
||||
},
|
||||
)
|
||||
|
||||
graph = await _run_graph_snapshot(request, run)
|
||||
if any(node.type == "loop" for node in graph.nodes):
|
||||
raise HTTPException(
|
||||
status_code=409,
|
||||
detail={
|
||||
"code": "WORKFLOW_RUN_CONFLICT",
|
||||
"message": "包含循环节点的流程暂不支持定点重跑,请重新执行整条流程",
|
||||
},
|
||||
)
|
||||
node_id = body.node_id.strip()
|
||||
target = graph.node_map().get(node_id)
|
||||
if target is None:
|
||||
raise HTTPException(
|
||||
status_code=404,
|
||||
detail={"code": "WORKFLOW_NODE_NOT_FOUND", "message": "指定节点不在原运行图中"},
|
||||
)
|
||||
if target.type not in {"agent", "skill"}:
|
||||
raise HTTPException(
|
||||
status_code=400,
|
||||
detail={
|
||||
"code": "WORKFLOW_NODE_NOT_FOUND",
|
||||
"message": "目前只能对智能体或技能节点发起定点反馈",
|
||||
"nodeId": node_id,
|
||||
},
|
||||
)
|
||||
|
||||
feedback_message = body.message.strip()
|
||||
if not feedback_message:
|
||||
raise HTTPException(
|
||||
status_code=400,
|
||||
detail={"code": "WORKFLOW_INPUT_INVALID", "message": "修订说明不能为空"},
|
||||
)
|
||||
|
||||
user_id = await get_current_user(request)
|
||||
issues = await _run_validation_issues(
|
||||
request,
|
||||
workflow_id=run["workflow_id"],
|
||||
graph=graph,
|
||||
user_id=user_id,
|
||||
)
|
||||
if issues:
|
||||
first = issues[0].model_dump(by_alias=True)
|
||||
raise HTTPException(
|
||||
status_code=409,
|
||||
detail={
|
||||
"code": first.get("code") or "WORKFLOW_SCHEMA_INVALID",
|
||||
"message": "原执行图的依赖已不可用,无法创建修订运行",
|
||||
"nodeId": first.get("nodeId"),
|
||||
"details": {"issues": [issue.model_dump(by_alias=True) for issue in issues]},
|
||||
},
|
||||
)
|
||||
|
||||
current_rows = await _runs(request).list_node_runs(run_id, current_only=True)
|
||||
target_row = next((row for row in current_rows if row.get("node_id") == node_id), None)
|
||||
if target_row is None or target_row.get("status") != "completed":
|
||||
raise HTTPException(
|
||||
status_code=409,
|
||||
detail={
|
||||
"code": "WORKFLOW_RUN_CONFLICT",
|
||||
"message": "只能对原运行中已完成的智能体节点发起定点反馈",
|
||||
"nodeId": node_id,
|
||||
},
|
||||
)
|
||||
|
||||
runs = _runs(request)
|
||||
active = [row for row in await runs.list_runs(owner_id=user_id, limit=200) if row["status"] in ("queued", "running")]
|
||||
if len(active) >= _cfg().max_concurrent_runs_per_user:
|
||||
raise HTTPException(
|
||||
status_code=429,
|
||||
detail={
|
||||
"code": "WORKFLOW_LIMIT_EXCEEDED",
|
||||
"message": f"同时运行的工作流已达上限({_cfg().max_concurrent_runs_per_user})",
|
||||
},
|
||||
)
|
||||
|
||||
affected = _downstream_nodes(graph, node_id)
|
||||
reusable_rows = [
|
||||
row
|
||||
for row in current_rows
|
||||
if row.get("status") == "completed" and row.get("node_id") not in affected
|
||||
]
|
||||
reused_node_ids = sorted(str(row["node_id"]) for row in reusable_rows)
|
||||
fingerprint = hashlib.sha256(
|
||||
f"{run_id}\x1f{node_id}\x1f{feedback_message}".encode()
|
||||
).hexdigest()[:24]
|
||||
# Do not truncate an arbitrary 128-character client key: that could make
|
||||
# two different keys with the same prefix collide. Hashing preserves a
|
||||
# compact, stable key for both client-supplied retries and server-derived
|
||||
# semantic retries.
|
||||
client_key = str(body.idempotency_key or fingerprint)
|
||||
client_fingerprint = hashlib.sha256(client_key.encode()).hexdigest()[:24]
|
||||
idempotency_key = f"revision:{run_id}:{client_fingerprint}"
|
||||
parent_context = dict(run.get("context") or {})
|
||||
parent_context.pop("resume_payload", None)
|
||||
parent_context.pop("loop_state", None)
|
||||
parent_env = parent_context.get("env")
|
||||
env = dict(parent_env) if isinstance(parent_env, dict) else {}
|
||||
env["nodeFeedback"] = {
|
||||
node_id: {
|
||||
"message": feedback_message,
|
||||
"sourceRunId": run_id,
|
||||
}
|
||||
}
|
||||
parent_context.update(
|
||||
{
|
||||
"env": env,
|
||||
"revisionOfRunId": run_id,
|
||||
"feedback": {
|
||||
"targetNodeId": node_id,
|
||||
"message": feedback_message,
|
||||
"affectedNodeIds": sorted(affected),
|
||||
"reusedNodeIds": reused_node_ids,
|
||||
"submittedAt": datetime.now(UTC).isoformat(),
|
||||
},
|
||||
}
|
||||
)
|
||||
new_run, created = await runs.create_run(
|
||||
{
|
||||
"workflow_id": run["workflow_id"],
|
||||
"workflow_version_id": run["workflow_version_id"],
|
||||
"owner_id": user_id,
|
||||
"input": run.get("input") or {},
|
||||
"idempotency_key": idempotency_key,
|
||||
"retry_of_run_id": run_id,
|
||||
"context": parent_context,
|
||||
}
|
||||
)
|
||||
if not created:
|
||||
return {**_public_run(new_run), "created": False, "reused": True}
|
||||
|
||||
for row in reusable_rows:
|
||||
await runs.record_node_run(
|
||||
{
|
||||
"run_id": new_run["id"],
|
||||
"node_id": row["node_id"],
|
||||
"node_type": row.get("node_type") or "unknown",
|
||||
"status": "completed",
|
||||
"attempt": 1,
|
||||
"iteration": int(row.get("iteration") or 0),
|
||||
"output": row.get("output"),
|
||||
"duration_ms": row.get("duration_ms"),
|
||||
"is_current": True,
|
||||
}
|
||||
)
|
||||
await _events(request).append(
|
||||
run_id=new_run["id"],
|
||||
workflow_id=new_run["workflow_id"],
|
||||
version_id=new_run["workflow_version_id"],
|
||||
event_type="run.created",
|
||||
payload={
|
||||
"revisionOfRunId": run_id,
|
||||
"targetNodeId": node_id,
|
||||
"affectedNodeIds": sorted(affected),
|
||||
"reusedNodeIds": reused_node_ids,
|
||||
},
|
||||
)
|
||||
_nudge(request)
|
||||
audit_workflow(
|
||||
"run.feedback_revision",
|
||||
user_id=user_id,
|
||||
runId=new_run["id"],
|
||||
revisionOfRunId=run_id,
|
||||
nodeId=node_id,
|
||||
affectedNodeIds=sorted(affected),
|
||||
)
|
||||
return {
|
||||
**_public_run(new_run),
|
||||
"created": True,
|
||||
"reused": False,
|
||||
"affectedNodeIds": sorted(affected),
|
||||
"reusedNodeIds": reused_node_ids,
|
||||
}
|
||||
|
||||
|
||||
# ── events / SSE ────────────────────────────────────────────────────────
|
||||
|
||||
|
||||
@@ -641,6 +1141,7 @@ async def stream_run(
|
||||
next_poll = 0.0
|
||||
last_beat = loop.time()
|
||||
try:
|
||||
yield f": stream-ready{_SSE_FLUSH_PADDING}\n\n"
|
||||
while loop.time() < deadline:
|
||||
if await request.is_disconnected():
|
||||
return
|
||||
|
||||
Reference in new issue
Block a user