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

起因是一次探索运行: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
+309 -1
View File
@@ -1,7 +1,18 @@
import { useStudio } from '../store/studio'
import { applyDerived, type GraphLike } from './derive'
import { project, type NodeState, type NodeTrace, type Projection, type Trace } from './trace'
import type { NodeRuntime } from '../types'
import type { NodeRuntime, RunEvent } from '../types'
/** 某一刻为止的用量:实时是航迹上的累计,回放是那一刻的刻度 */
export interface NodeUsage {
tokensIn: number
tokensOut: number
costUsd: number
tools: number
toolsRunning: number
}
const NO_USAGE: NodeUsage = { tokensIn: 0, tokensOut: 0, costUsd: 0, tools: 0, toolsRunning: 0 }
/**
* 节点卡取状态的唯一入口。
@@ -24,6 +35,8 @@ export interface NodeView {
/** 执行了几次(循环、接着跑都会 > 1)。回放时是那一刻之前的次数 */
count: number
iteration?: number
/** token 和工具次数。回放时是游标那一刻的读数,不拿终值冒充 */
usage: NodeUsage
/** 回放时这一刻的执行用时(进行中是已经用了多久,结束了是那一段的用时) */
replayElapsedMs?: number
/** 回放游标(毫秒时间戳);实时为 null。卡片据此把计时、协作矩阵截到那一刻 */
@@ -110,6 +123,7 @@ export function useNodeView(id: string): NodeView {
trace: node,
count: projected?.count ?? 0,
iteration: projected?.iteration,
usage: projected ?? NO_USAGE,
replayElapsedMs: projected?.elapsedMs,
at,
looping: !!derived?.looping,
@@ -122,11 +136,305 @@ export function useNodeView(id: string): NodeView {
trace: node,
count: node?.count ?? 0,
iteration: node?.iteration ?? runtime?.iteration,
usage: node ?? NO_USAGE,
at: null,
looping: !!node?.looping,
}
}
// -------------------------------------------------------------------------
// 节点上的几件"事":航迹只记状态和用量,这些要从事件里捞
// -------------------------------------------------------------------------
/** 一次工具调用的起止。时刻都是毫秒,和航迹同一条时间轴 */
export interface ToolSpan {
tool: string
agent?: string
callId?: string
start: number
end?: number
/** 后端声明的时限(tool.start.timeout_s)。没声明的工具不掐时 */
limitS?: number
ok?: boolean
timedOut?: boolean
}
/** 某件事什么时候发生、原话怎么说 */
export interface FactMark {
at: number
message: string
}
/**
* 模型把工具调用写成了文字(log code=tool_markup_leak)。后端在两种时候发它:
* 写成文字被提醒、重答了(nudge,「…已提醒它重试一次」),成果是重答的那一次;
* 步数用完后的收尾轮还想要工具(settle,「…收尾轮仍想调用工具」),交出来的是
* 它前面写的内容,可能不完整。两件事对成果的意思不一样,卡片分开说
*/
export interface MarkupMark extends FactMark {
settle: boolean
}
/**
* 协作团队的收尾判定:轮数用完之后调度者只判定、不派活的那一次决定。它不是新的
* 一轮,矩阵不给它加一列。at 是开始判定(agent.route.start),end 是给出结论
*/
export interface ClosingMark {
at: number
end?: number
round: number
done: boolean
reason: string
}
/** 协作成员失败(agent.step.end 的 failed / error) */
export interface MemberFail {
at: number
agent: string
error: string
}
/**
* 卡片要说清的几件事。它们都藏在事件里:log 的 code、agent.route 的 closing、
* tool.start 的 timeout_s——航迹不存,runtime 也不存。按节点归好,卡片直接取。
*
* 一次运行里同一个节点会执行好几次(循环体每一轮、失败后接着跑),每件事都按
* 先后留着:卡片只说游标所在的那一次执行里发生的(见 execStart、lastIn),上一次
* 用完轮数、收尾时还想调工具,不能挂到这一次干干净净的结果上
*/
export interface NodeFacts {
/** 整次运行里的工具调用,按开始先后。回放按游标截 */
calls: ToolSpan[]
/**
* 最近一次执行从什么时候开始(审批恢复的重放不算新的一次,接着跑算)。
* 卡片取执行的起点用 execStart:它和卡片上的执行次数同出航迹,回放也认得
*/
since: number
/** 在等审批:这之后再来的 node.started 是恢复重放,不是新的一次执行 */
paused?: boolean
/** 下面三个是整次运行里最后的那一次,给只看整次运行的地方;卡片用对应的列表 */
markup?: MarkupMark
exhausted?: FactMark
invented?: FactMark
/** 模型把工具调用写成了文字,每次都留着 */
markups: MarkupMark[]
/** 协作团队轮数用完、按降档交付(log code=team_exhausted) */
exhausts: FactMark[]
/** 修复被拒:结果里出现了原文没有的值(log code=repair_invented) */
inventions: FactMark[]
closings: ClosingMark[]
memberErrors: MemberFail[]
/** 每一次失败的报错(node.failed)。回放到更早的一次失败时取那一次的原话 */
failures: FactMark[]
/** 校验修复调模型的时刻(llm.end purpose=repair),按先后 */
repairs: number[]
}
const EMPTY_FACTS: NodeFacts = {
calls: [], since: 0, markups: [], exhausts: [], inventions: [], closings: [], memberErrors: [], failures: [], repairs: [],
}
const tsOf = (e: RunEvent): number | undefined =>
(typeof e.ts === 'number' && Number.isFinite(e.ts) ? e.ts * 1000 : undefined)
/**
* 事件落到哪个节点上。等审批的两条有时不带 node_id,节点写在 data 里
*/
function factNode(e: RunEvent, d: Record<string, any>): string | undefined {
if (e.node_id) return e.node_id
if (e.type === 'run.interrupted' && d.payload?.node_id) return String(d.payload.node_id)
if (e.type === 'human.requested' && d.node_id) return String(d.node_id)
return undefined
}
/** clock:没带时间戳的事件记在最近一个时间戳上,和航迹的时间轴一致 */
function foldFacts(map: Record<string, NodeFacts>, e: RunEvent, clock: number): void {
const d = (e.data ?? {}) as Record<string, any>
const id = factNode(e, d)
if (!id) return
const at = tsOf(e) ?? clock
const cur = map[id] ?? EMPTY_FACTS
let next: NodeFacts | null = null
switch (e.type) {
case 'node.started':
// 和航迹同一条规则:只有等审批之后的那次重放接着算同一次执行。接着跑时
// 后端也给失败的节点标 resumed,但那是重新执行,上一次的事不再算它的
next = cur.paused ? { ...cur, paused: false } : { ...cur, since: at }
break
case 'human.requested':
case 'run.interrupted':
if (!cur.paused) next = { ...cur, paused: true }
break
case 'node.finished':
case 'node.skipped':
if (cur.paused) next = { ...cur, paused: false }
break
case 'node.failed':
next = {
...cur, paused: false,
failures: [...cur.failures, { at, message: typeof d.error === 'string' ? d.error : '' }],
}
break
case 'tool.start': {
const limit = Number(d.timeout_s)
next = {
...cur,
calls: [...cur.calls, {
tool: String(d.tool ?? ''), start: at,
...(d.agent != null ? { agent: String(d.agent) } : {}),
...(d.call_id != null ? { callId: String(d.call_id) } : {}),
...(Number.isFinite(limit) && limit > 0 ? { limitS: limit } : {}),
}],
}
break
}
case 'tool.end':
case 'tool.error': {
// 有 call_id 按它配;老事件没有就按「同一个成员、同名、还开着的最后一次」
const tool = String(d.tool ?? '')
let i = -1
for (let k = cur.calls.length - 1; k >= 0; k -= 1) {
const c = cur.calls[k]
if (c.end != null) continue
if (d.call_id != null ? c.callId === String(d.call_id)
: c.tool === tool && (d.agent == null || c.agent === String(d.agent))) { i = k; break }
}
if (i < 0) break
const calls = [...cur.calls]
calls[i] = { ...calls[i], end: at, ok: e.type === 'tool.end', ...(d.timed_out ? { timedOut: true } : {}) }
next = { ...cur, calls }
break
}
case 'log': {
const message = String(d.message ?? '')
if (d.code === 'tool_markup_leak') {
const mark = { at, message, settle: /收尾轮/.test(message) }
next = { ...cur, markup: mark, markups: [...cur.markups, mark] }
} else if (d.code === 'team_exhausted') {
next = { ...cur, exhausted: { at, message }, exhausts: [...cur.exhausts, { at, message }] }
} else if (d.code === 'repair_invented') {
next = { ...cur, invented: { at, message }, inventions: [...cur.inventions, { at, message }] }
}
break
}
case 'agent.route.start':
if (d.closing) {
next = { ...cur, closings: [...cur.closings, { at, round: Number(d.round) || 0, done: false, reason: '' }] }
}
break
case 'agent.route.end':
if (d.closing) {
// 收掉开着的那一次;老后端没发 route.start 时起止记成同一刻
const last = cur.closings[cur.closings.length - 1]
const open = last && last.end == null ? last : undefined
const mark: ClosingMark = {
at: open?.at ?? at, end: at, round: Number(d.round) || 0, done: d.done === true, reason: String(d.reason ?? ''),
}
next = { ...cur, closings: open ? [...cur.closings.slice(0, -1), mark] : [...cur.closings, mark] }
}
break
case 'agent.step.end':
if (d.failed || d.error) {
const agent = String(d.agent ?? '')
const error = typeof d.error === 'string' && d.error.trim() ? d.error.trim() : '这一步失败了,没有给出原因'
next = { ...cur, memberErrors: [...cur.memberErrors, { at, agent, error }] }
}
break
case 'llm.end':
if (d.purpose === 'repair') next = { ...cur, repairs: [...cur.repairs, at] }
break
}
if (next) map[id] = next
}
/**
* 事件只会往后追加:上一次折到第几条就从第几条接着折,每来一条只做一条的事。
* 没变的节点沿用原对象,卡片的选择器拿到的引用不变,不会跟着别的节点重渲染
*/
let factsMemo: { events: RunEvent[]; map: Record<string, NodeFacts>; clock: number } | null = null
export function factsOf(events: RunEvent[]): Record<string, NodeFacts> {
const memo = factsMemo
if (memo && memo.events === events) return memo.map
const n = memo?.events.length ?? 0
const appended = !!memo && events.length >= n && (n === 0 || events[n - 1] === memo.events[n - 1])
const map: Record<string, NodeFacts> = appended ? { ...memo!.map } : {}
let clock = appended ? memo!.clock : 0
for (let i = appended ? n : 0; i < events.length; i += 1) {
const ts = tsOf(events[i])
if (ts != null && ts > clock) clock = ts
foldFacts(map, events[i], clock)
}
factsMemo = { events, map, clock }
return map
}
export function useNodeFacts(id: string): NodeFacts | undefined {
return useStudio((s) => factsOf(s.events)[id])
}
/**
* 卡片在说的那一次执行从什么时候开始:游标那一刻(实时是最后)所在的那一次。
*
* 取航迹上最后一段已经开始的执行段——卡片头上的「×N」、回放时的状态都出自航迹,
* 事实跟着同一个划分走,才不会说成两次执行。审批恢复接回的段(resumed)和中断前
* 是同一次,不算起点;接着跑、循环的下一轮是新的一次。航迹里没有这个节点时退回
* 事件里记的起点,回放时就不截
*/
export function execStart(n: NodeTrace | undefined, at: number | null, facts?: NodeFacts): number {
const segs = n?.segments ?? []
for (let i = segs.length - 1; i >= 0; i -= 1) {
const s = segs[i]
if (s.kind !== 'run' || s.resumed || (at != null && s.start > at)) continue
return s.start
}
return at == null ? facts?.since ?? -Infinity : -Infinity
}
/** 从 since 到游标那一刻(实时到最后)之间的那几件,按先后 */
export function within<T extends { at: number }>(list: readonly T[] | undefined, at: number | null, since = -Infinity): T[] {
return (list ?? []).filter((x) => x.at >= since && (at == null || x.at <= at))
}
/** 从 since 到游标那一刻之间最后的那一件 */
export function lastIn<T extends { at: number }>(list: readonly T[] | undefined, at: number | null, since = -Infinity): T | undefined {
const all = list ?? []
for (let i = all.length - 1; i >= 0; i -= 1) {
const x = all[i]
if (at != null && x.at > at) continue
return x.at >= since ? x : undefined
}
return undefined
}
/**
* 某一刻在跑的那次工具调用(回放给游标,实时给 null)。多个同时开着时取最后开的,
* 卡片槽里只放得下一个名字。since 是这一次执行的起点:上一次撒手没收尾的调用不算
*/
export function openCall(facts: NodeFacts | undefined, at: number | null,
since = at == null ? facts?.since ?? 0 : -Infinity): ToolSpan | undefined {
const calls = facts?.calls ?? []
for (let i = calls.length - 1; i >= 0; i -= 1) {
const c = calls[i]
if (c.start < since) continue
if (at == null ? c.end == null : c.start <= at && (c.end == null || c.end > at)) return c
}
return undefined
}
/** 这一次执行里校验修复了几次。回放时数到游标为止 */
export function repairsOf(facts: NodeFacts | undefined, at: number | null,
since = at == null ? facts?.since ?? 0 : -Infinity): number {
return (facts?.repairs ?? []).filter((t) => t >= since && (at == null || t <= at)).length
}
/**
* 某件事在游标那一刻发生了没有(实时一律算发生了)。给了 since 就只认这一次执行里的。
* 这里只有最后那一件:回放到更早的一次执行时它可能还没发生,要逐次看就用 lastIn
*/
export const happened = <T extends { at: number }>(fact: T | undefined, at: number | null, since = -Infinity): T | undefined =>
(fact && (at == null || fact.at <= at) && fact.at >= since ? fact : undefined)
/**
* 最后一段还开着的某类段从什么时候开始。实时计时从这里起算。
* 给了回放游标就只看那一刻:那时已经开始、还没结束的段