第三波前两批:六个「看着成功其实没干活」的平台漏洞堵上,记录页能回放,管理页与画布收尾

起因是一次探索运行:Copilot 改节点时把工具绑定整份抹掉,agent 没有工具只能写「假设调用」,
校验节点的自动修复编出 total_count=0 让 schema 通过,协作成员把工具调用标记当文字输出了四轮,
轮数用完后节点把原话当成功结果交出去——运行标成已完成,数据库一次都没查。

平台可信度(先写失败测试)
- Copilot 修改节点改为合并:没写的字段保留,null 才删除;协作成员按名字合并。前后端同一套规则,
  工具集合变小时自查报警、改图回执列出变化
- 新校验规则:提示词点名了某个工具而节点没有绑定它,判错误,Copilot 自查会交回去修
- 校验修复只许改格式:冒出原文没有的值就判修复无效;修复这次模型调用计入用量
- 识别模型把工具调用写成文字的情况(DSML、<tool_call> 等标记):纠正一次,仍然如此就判失败并说明原因
- 协作团队用完轮数不再按成功交付:默认失败,可选降档,点出一次都没派到的成员
- 审批恢复后,同一节点里已经执行过的工具调用复用结果,不再重复执行

后端
- 查询时限交给数据库执行(Oracle call_timeout、PG statement_timeout、MySQL max_execution_time、
  SQLite progress handler),可按数据源配置;超时报错与实际耗时一致
- 等审批的运行可以真正取消;会话列表带最后一轮状态;测连接结果持久化;探查结构可只看不存;
  自定义工具可草稿试跑、写坏的参数定义保存时拒绝;MCP 服务改动后作废旧工具缓存;
  检索命中带贡献分解;重建索引在后台跑并报进度;报错统一收进 core/errors

前端
- 公共层:管理页共用件、失败说明(lib/explain)、健康状态进公共库;目录按表各自加载并有超时,
  一张表卡住不再拖垮整站;上传显示真实字节进度;离线横幅只播报不变的句子
- 画布:卡片只说游标所在的那一次执行;等审批时可放弃运行;团队收尾判定与未完成说清楚;
  回放用量取那一刻的值
- 编排页:Copilot 合并语义与工具变化回执;「用完轮数时」选项;正式运行期间锁住所有改图入口
- 回答流 / 问数据:新失败类型说人话并给下一步;画布与右栏互相定位;数据源范围、回收站、重新核对
- 记录页:「航迹」页签复用画布时间轴,可拖动回放、列出关键时刻;列表行带执行 / 等人 / 失败缩略条
- 外壳:统一的离开前确认(data router),导航、⌘K、快捷键、后退都会先问

验证(沙箱):tsc 干净,pytest 838 passed(两遍),14 个检查脚本中 13 个全绿;
check-ui 余 1 项旧断言(按旧日期格式找运行行),3c 更新。
This commit is contained in:
ThearchyHelios
2026-09-27 10:16:32 +08:00
parent e10c4f23fc
commit 587bf7e27c
134 changed files with 20140 additions and 2709 deletions
+116 -7
View File
@@ -10,7 +10,7 @@ from pydantic import BaseModel, Field
from sqlalchemy import select
from sqlalchemy.ext.asyncio import AsyncSession
from app.api.errors import explain, raw
from app.core.errors import explain, raw
from app.core.config import settings
from app.db.base import get_session
from app.db.models import Document, MemoryItem, Skill
@@ -433,20 +433,129 @@ async def probe_embedding(base_url: str) -> dict[str, Any]:
return {"base_url": base_url, "models": models}
class _ReindexJob:
"""一次重建索引。进度按批更新:kb / store 每提交一批回调一次,不插值。"""
def __init__(self, collection: str | None, chunks: int, memories: int) -> None:
from app.db.base import new_id, utcnow
self.id = new_id()
self.collection = collection
self.state = "running" # running | done | failed
# chunks → index(倒排重建,没有分批进度)→ memories → done
self.phase = "chunks"
self.chunks = {"total": chunks, "done": 0}
self.memories = {"total": memories, "done": 0}
self.started_at = utcnow()
self.finished_at: Any = None
self.error: str | None = None
self.hint: str | None = None
self.result: dict[str, Any] | None = None
def chunk_step(self, done: int, total: int) -> None:
self.chunks = {"total": total, "done": done}
if done >= total:
self.phase = "index"
def memory_step(self, done: int, total: int) -> None:
self.memories = {"total": total, "done": done}
def view(self) -> dict[str, Any]:
return {
"id": self.id, "state": self.state, "phase": self.phase,
"collection": self.collection,
"total": self.chunks["total"] + self.memories["total"],
"done": self.chunks["done"] + self.memories["done"],
"chunks": dict(self.chunks), "memories": dict(self.memories),
"started_at": self.started_at.isoformat(),
"finished_at": self.finished_at.isoformat() if self.finished_at else None,
"error": self.error, "hint": self.hint, "result": self.result,
}
#: 最近一次重建。只在进程里记:重建是幂等的,服务重启丢了进度,再点一次就是
_REINDEX: _ReindexJob | None = None
#: 后台任务要有人拿着引用,否则跑到一半可能被回收
_REINDEX_TASK: Any = None
def reindex_job() -> _ReindexJob | None:
return _REINDEX
async def _run_reindex(job: _ReindexJob) -> None:
from app.db.base import SessionLocal, utcnow
try:
async with SessionLocal() as session:
out = await kb.reindex(session, job.collection, on_progress=job.chunk_step)
job.phase = "memories"
# 记忆不按 collection 分,重建就是全量
out["memories_reindexed"] = await store.reindex(session, on_progress=job.memory_step)
job.result, job.state, job.phase = out, "done", "done"
except Exception as e: # noqa: BLE001 - 失败要落到任务状态上,不能只进日志
logger.warning("重建索引失败:%s", raw(e))
reason, hint = explain(e)
job.state, job.error, job.hint = "failed", f"重建索引没做完:{reason}", hint or None
finally:
job.finished_at = utcnow()
@kb_router.post("/reindex")
async def reindex(
collection: str | None = None, session: AsyncSession = Depends(get_session)
) -> dict[str, Any]:
collection: str | None = None,
background: bool = Query(default=False, description="后台跑,立刻返回任务;进度用 GET /kb/reindex 查"),
session: AsyncSession = Depends(get_session),
):
"""用当前 embedder 重算向量。换了模型之后唯一的恢复手段。
知识库和长期记忆一起重建:它们共用一个 embedder,换模型时一起失效。
分成两个按钮的结果是点了一个、以为好了,另一个还在悄悄退回关键词——
真踩过,记忆那边连个提示都没有。
几千段配远端 embedding 要好几分钟,压在请求里界面只能干转圈。background=true
时立刻返回 202 和任务,按批更新进度;不带它仍然等做完再返回,老调用方不受影响。
同一时间只跑一个:两次重建交错写同一批向量,谁最后写赢都说不清。
"""
out = await kb.reindex(session, collection)
# 记忆不按 collection 分,重建就是全量
out["memories_reindexed"] = await store.reindex(session)
return out
global _REINDEX, _REINDEX_TASK
import asyncio
from fastapi.responses import JSONResponse
from sqlalchemy import func
from app.db.models import Chunk
count = select(func.count(Chunk.id))
if collection:
count = count.where(Chunk.collection == collection)
chunks = int((await session.execute(count)).scalar_one() or 0)
memories = int((await session.execute(select(func.count(MemoryItem.id)))).scalar_one() or 0)
# 先数完再查「有没有在跑」,查和占位之间不能有 await:以前先查后数,两个同时
# 到的请求都在计数那里让出去,回来都以为没在跑,于是两个都起了
if _REINDEX is not None and _REINDEX.state == "running":
running = _REINDEX.view()
raise HTTPException(
409, f"已经在重建索引了({_REINDEX.collection or '全部集合'},"
f"已完成 {running['done']}/{running['total']}),等它做完再点",
)
job = _REINDEX = _ReindexJob(collection, chunks, memories)
if background:
_REINDEX_TASK = asyncio.create_task(_run_reindex(job))
return JSONResponse(job.view(), status_code=202)
await _run_reindex(job)
if job.state == "failed":
raise HTTPException(502, job.error + (f"。{job.hint}" if job.hint else ""))
return job.result
@kb_router.get("/reindex")
async def reindex_status() -> dict[str, Any]:
"""最近一次重建的进度:{state, phase, total, done, chunks, memories, result, error…}。
还没重建过返回 {state: "idle"}。
"""
return _REINDEX.view() if _REINDEX is not None else {"state": "idle"}
#: 单段返回多少字。切块本来就在千字量级,详情页是给人扫一眼"切得对不对"的,