mirror of
https://github.com/ThearchyHelios/AgentLab.git
synced 2026-11-21 03:12:00 +00:00
第三波前两批:六个「看着成功其实没干活」的平台漏洞堵上,记录页能回放,管理页与画布收尾
起因是一次探索运行: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:
@@ -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)
|
||||
|
||||
/**
|
||||
* 最后一段还开着的某类段从什么时候开始。实时计时从这里起算。
|
||||
* 给了回放游标就只看那一刻:那时已经开始、还没结束的段
|
||||
|
||||
Reference in New Issue
Block a user