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:
董宏凯 committed 2026-09-01 11:47:30 +08:00
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