mirror of
https://github.com/ThearchyHelios/AgentLab.git
synced 2026-11-19 10:31:59 +00:00
d18a496ef9
为什么:一轮问数据以前是浏览器在推(store/chat.ts 的 plan / launch / settle):网络一抖建图那条流就断、建了一半的图丢掉;
发起运行、复核、重来、落库都要页面在,页面一关这一轮就停在 running,15 分钟后才被判成断了(总方案 §0 的调查结论)。
做了什么:
- 流程和评测共用一份:eval/answer.Driver 里的流程抽到 chat/drive.TurnDriver,差异写成子类给的几项(生成的请求、目录视图、
改图、入口、发起参数、停在审批上怎么办、复核等多久)。评测的 Driver 成了它的子类,行为和测试一字不变(test_eval_* 照跑)。
- chat/job.py:问数据的一轮是 core/job_runtime 上的后台任务(不占数据源的队,并发归「交互」类,第 2 波再给上限和优先级)。
停在审批上照旧等人(评测是取消);复核最多等 25 秒,晚到的那次用量照记(review.late);按复核自动重来一次;用户点的
重试本轮、重新运行、放宽步数、跑一下、继续运行、接着收尾都是同一轮里的一次尝试,上一次的结局归档进 meta.attempts。
- 事件日志(新表 chat_turn_events,models_chat.py,不进运行的封存范围):每一步按 seq 落库再叫醒订阅方,订阅方按 seq
回库里读——回放和实时是同一段代码;心跳一拍也回库里看一次,第 2 波多进程时别的进程写的最迟一拍送到。
- 接口 api/chat_turns.py:POST /api/chat/turns(202 带 turn_id)、GET /{id}、GET /{id}/stream?after=(SSE:先回放、再推
实时、带心跳、结束补 stream.end)、POST /{id}/cancel。挂 chat_scope,每个接口按这一轮所属的对话核对归属;访问密钥调不了。
- conversation_turns 那一行由服务端写(chat/record.py:状态、运行 id、答案、复核、meta 各项和页面以前写的一一对应);失败
只记原因(meta.cause),说法留在界面层按 lib/explain 讲。TurnOut 带这一轮的任务(job),列表判「还在跑」先看任务。
- 使用者的问数据运行规则(白名单、自己的记忆范围、遮罩、只读)抽到 chat/launch.user_chat_run,POST /api/runs 和服务端的
一轮共用,说法一字不变。
- 服务重启:还在建图的标中断(可重试本轮);已发起运行的接着等那次运行、照常复核收尾;和调度循环同一个开关,拷来的数据
目录启动时不替人收尾,页面打开对话时再请服务端接着收尾(mode=resume)。老轮次停在建图中的同样标中断。
- 删对话时先停掉它正在跑的几轮(取消各自的运行),任务和事件日志一并删。
测试:tests/test_chat_turns.py——一轮跑完不依赖页面、直接回答与反问、开流前被拒、实时流回放后接实时与按 seq 重连(补齐、
不重复)、思考合并、建图中与运行中停止、重启时建图中标中断与已发起运行的接着收尾、开关关着时等人来接、等审批后收尾、
按复核重来、用户重试归档、一段对话一次一轮、继续运行被拒照 /runs 的说法、删对话停掉这一轮、使用者的归属与遮罩只读、
访问密钥调不了、驳回与失败与发起被拒的原因、晚到的复核、跑一下与重新运行不重建。去掉几处关键实现回跑,相应的测试都会失败。
139 lines
6.2 KiB
Python
139 lines
6.2 KiB
Python
"""问数据一轮的事件日志(chat_turn_events,见 db/models_chat.py):追加、回放、实时推送。
|
|
|
|
**为什么「先落库、再通知、订阅方回库里读」。** 页面要的是:先回放、再接实时,断了按 seq 补齐,刷新、关掉再打开都能接着看。
|
|
事件一律先写库,再叫醒等着的订阅方,订阅方按自己收到的最后一个 seq 回库里读——实时和回放是同一段代码,补齐不会漏、不会重复,
|
|
也不用像运行的事件总线那样处理慢消费者的积压。订阅方在读库**之前**先登记等待(watch),读完没东西才睡:读和写之间新写进来的
|
|
那一条会把它叫醒,不会漏掉。
|
|
|
|
叫醒只在本进程里(进程内的事件);隔一拍心跳(HEARTBEAT_S)订阅方也会回库里看一次,所以换成多进程(第 2 波)时,别的进程写的
|
|
事件最迟一拍心跳就送到——那时再换成 PostgreSQL 的 LISTEN/NOTIFY,这里的接口不用变。
|
|
|
|
线上格式(SSE,每条一行 data: <JSON>):{seq, type, data, ts};回放完、这一轮也不在进行中了,补一条不带 seq 的
|
|
{type: stream.end, status}(任务的状态)再关;隔一拍没有新事件发一行注释心跳「: ping」(页面据此知道连接还活着)。
|
|
事件种类见 app/chat/job.py 的模块说明。
|
|
"""
|
|
from __future__ import annotations
|
|
|
|
import asyncio
|
|
import contextlib
|
|
import json
|
|
import time
|
|
from collections import defaultdict
|
|
from collections.abc import AsyncIterator, Awaitable, Callable, Iterator
|
|
from typing import Any
|
|
|
|
from sqlalchemy import func, select, update
|
|
from sqlalchemy.ext.asyncio import AsyncSession
|
|
|
|
from app.db.base import SessionLocal
|
|
|
|
#: 隔多久没有新事件就发一拍心跳(秒),也是订阅方回库里看一次的间隔
|
|
HEARTBEAT_S = 15.0
|
|
#: 一次回放最多读多少条
|
|
READ_BATCH = 500
|
|
#: 回放、实时推送完、这一轮不在进行中时的结束标记(不落库、不带 seq)
|
|
STREAM_END = "stream.end"
|
|
|
|
|
|
class _Waiters:
|
|
"""本进程里等某一轮新事件的订阅方:一个订阅方一个 asyncio.Event。"""
|
|
|
|
def __init__(self) -> None:
|
|
self._by_turn: dict[str, set[asyncio.Event]] = defaultdict(set)
|
|
|
|
@contextlib.contextmanager
|
|
def watch(self, turn_id: str) -> Iterator[asyncio.Event]:
|
|
event = asyncio.Event()
|
|
self._by_turn[turn_id].add(event)
|
|
try:
|
|
yield event
|
|
finally:
|
|
waiters = self._by_turn.get(turn_id)
|
|
if waiters is not None:
|
|
waiters.discard(event)
|
|
if not waiters:
|
|
self._by_turn.pop(turn_id, None)
|
|
|
|
def notify(self, turn_id: str) -> None:
|
|
for event in list(self._by_turn.get(turn_id, ())):
|
|
event.set()
|
|
|
|
|
|
waiters = _Waiters()
|
|
|
|
|
|
def notify(turn_id: str) -> None:
|
|
"""这一轮有了变化(新事件、任务状态变了):叫醒本进程里等着的订阅方。"""
|
|
waiters.notify(turn_id)
|
|
|
|
|
|
async def append(session: AsyncSession, turn_id: str, type_: str, data: dict[str, Any] | None = None) -> int:
|
|
"""追加一条,提交,叫醒订阅方。交回它的 seq。
|
|
|
|
seq 按这一轮库里已有的最大值往下接:同一轮同一时刻只有一个写的人(它的后台任务;任务不在跑时才由停止、启动整理来写),
|
|
唯一约束 (turn_id, seq) 兜底。任务行的 last_seq 顺手跟上(GET /api/chat/turns/{id} 照它说现在到哪了)。"""
|
|
from app.db.models_chat import ChatTurnEvent, ChatTurnJob
|
|
|
|
last = int(await session.scalar(select(func.coalesce(func.max(ChatTurnEvent.seq), 0))
|
|
.where(ChatTurnEvent.turn_id == turn_id)) or 0)
|
|
seq = last + 1
|
|
session.add(ChatTurnEvent(turn_id=turn_id, seq=seq, type=type_, ts=time.time(), data=dict(data or {})))
|
|
await session.execute(update(ChatTurnJob).where(ChatTurnJob.id == turn_id).values(last_seq=seq)
|
|
.execution_options(synchronize_session=False))
|
|
await session.commit()
|
|
notify(turn_id)
|
|
return seq
|
|
|
|
|
|
def wire(row: Any) -> dict[str, Any]:
|
|
"""库里的一条 → 线上的一条。"""
|
|
return {"seq": row.seq, "type": row.type, "data": row.data or {}, "ts": row.ts}
|
|
|
|
|
|
async def read(turn_id: str, after: int = 0, limit: int = READ_BATCH) -> list[dict[str, Any]]:
|
|
"""seq > after 的事件(按 seq),最多 limit 条。"""
|
|
from app.db.models_chat import ChatTurnEvent
|
|
|
|
async with SessionLocal() as session:
|
|
rows = (await session.execute(
|
|
select(ChatTurnEvent).where(ChatTurnEvent.turn_id == turn_id, ChatTurnEvent.seq > after)
|
|
.order_by(ChatTurnEvent.seq).limit(limit))).scalars().all()
|
|
return [wire(r) for r in rows]
|
|
|
|
|
|
def frame(event: dict[str, Any]) -> str:
|
|
return f"data: {json.dumps(event, ensure_ascii=False, default=str)}\n\n"
|
|
|
|
|
|
#: 心跳(SSE 注释行):页面的解析器只认 data: 开头的帧,这一行只是告诉它连接还活着
|
|
PING = ": ping\n\n"
|
|
|
|
|
|
async def stream(turn_id: str, after: int, *, active: Callable[[], Awaitable[str | None]],
|
|
heartbeat: float | None = None) -> AsyncIterator[str]:
|
|
"""SSE 的每一帧:先回放 seq > after 的,再推实时的;这一轮不在进行中、也没有新的了,补一条 stream.end 再结束。
|
|
|
|
active() 交回这一轮还在进行中时为 None,不在进行中时交回任务的状态(stream.end 里带的就是它)。"""
|
|
beat = HEARTBEAT_S if heartbeat is None else heartbeat
|
|
last = after
|
|
while True:
|
|
with waiters.watch(turn_id) as woke:
|
|
rows = await read(turn_id, last)
|
|
for row in rows:
|
|
last = max(last, int(row["seq"]))
|
|
yield frame(row)
|
|
if rows:
|
|
continue
|
|
status = await active()
|
|
if status is not None:
|
|
yield frame({"type": STREAM_END, "status": status, "data": {"status": status}})
|
|
return
|
|
try:
|
|
await asyncio.wait_for(woke.wait(), timeout=beat)
|
|
except asyncio.TimeoutError:
|
|
yield PING
|
|
|
|
|
|
__all__ = ["HEARTBEAT_S", "PING", "READ_BATCH", "STREAM_END", "append", "frame", "notify", "read", "stream", "waiters",
|
|
"wire"]
|