Files
AgentLab/frontend/src/store/studio.ts
T

2515 lines
111 KiB
TypeScript
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
import { create } from 'zustand'
import {
addEdge, applyEdgeChanges, applyNodeChanges,
type Connection, type Edge, type EdgeChange, type Node, type NodeChange,
} from '@xyflow/react'
import { api, streamCopilot, streamRun } from '../api/client'
import { copilotReceipt, mergeNodeConfig, toolChangesOf } from '../canvas/copilotMerge'
import { connectMergeInput } from '../canvas/mergeInputs'
import { contentSig, isMissingEndpoint, normalizeUpgrade } from '../canvas/issues'
import { NODE_DEFS, sourceHandles } from '../canvas/nodeDefs'
import { toast } from '../components/ui'
import { humanizeError } from '../lib/errors'
import { formatShortcut } from '../lib/keys'
import { CATALOG_PATCH_TEXT, LOOK_TEXT, UPGRADE_TEXT, publishedLevelOf } from '../lib/terms'
import type { CopilotOp } from '../run/decode'
import type { LookEvent } from '../typesApp'
import { copilotContext, copilotLook, endingOf, looksOf, reduceTeam, settleTeam } from '../run/decode'
import { catalogPatchOf } from '../run/catalogPatch'
import { activeEdgesOf, applyDerived } from '../run/derive'
import {
emptyTrace, finalizeTrace, foldEvent, isActivePhase, isSettled, isTerminal, runStatusOf,
type NodeState, type RunPhase, type Trace,
} from '../run/trace'
import type {
ConversationTurn, CopilotCheckEntry, CopilotCheckIssue, CopilotCheckOp, GraphEdge, GraphSpec, NodeRuntime, NodeType, Run,
RunEvent, ToolChange, UpgradeResult, ValidationIssue, VarIssue, Variable, Workflow,
} from '../types'
export type FlowNode = Node<{ nodeType: NodeType; label: string; config: Record<string, any> }>
let idSeq = 0
const nextId = (type: string) => `${type}_${Date.now().toString(36).slice(-4)}${(idSeq++ % 100).toString(36)}`
// -------------------------------------------------------------------------
// GraphSpec ↔ React Flow 互转
// -------------------------------------------------------------------------
export function toFlow(graph: GraphSpec): { nodes: FlowNode[]; edges: Edge[] } {
return {
nodes: (graph.nodes ?? []).map((n) => ({
id: n.id,
type: 'card',
position: n.position ?? { x: 0, y: 0 },
data: {
nodeType: n.type,
label: n.data?.label ?? NODE_DEFS[n.type]?.label ?? n.type,
config: n.data?.config ?? {},
},
})),
edges: (graph.edges ?? []).map((e, i) => ({
id: e.id || `e${i}_${e.source}_${e.sourceHandle ?? ''}_${e.target}`,
source: e.source,
target: e.target,
sourceHandle: e.sourceHandle ?? null,
targetHandle: e.targetHandle ?? null,
label: e.label || undefined,
// 走线由 canvas/routing.ts 统一算(端口错开 + 走廊车道),
// 不用自带的 smoothstep:它的竖直段全都落在同一个 x 上,会叠成一团
type: 'flow',
animated: false,
})),
}
}
/**
* 图上节点和连线以外的部分(全图默认 defaults、viewport)。画布只管节点和连线,以前 toGraph
* 只拼这两样,保存时 PATCH 整张图,defaults 被整个抹掉——其中审批默认 always 会悄悄放宽成
* 全局设置。打开工作流时记下来,toGraph 原样带回去;和 savedSig 一样只属于当前这张图
*/
let graphExtras: Pick<GraphSpec, 'defaults' | 'viewport'> = {}
const extrasOf = (graph: GraphSpec | null | undefined): Pick<GraphSpec, 'defaults' | 'viewport'> => {
const out: Pick<GraphSpec, 'defaults' | 'viewport'> = {}
if (graph?.defaults && Object.keys(graph.defaults).length) out.defaults = structuredClone(graph.defaults)
if (graph?.viewport && Object.keys(graph.viewport).length) out.viewport = structuredClone(graph.viewport)
return out
}
export function toGraph(nodes: FlowNode[], edges: Edge[]): GraphSpec {
return {
...structuredClone(graphExtras),
nodes: nodes.map((n) => ({
id: n.id,
type: n.data.nodeType,
position: { x: Math.round(n.position.x), y: Math.round(n.position.y) },
data: { label: n.data.label, config: n.data.config },
})),
edges: edges.map<GraphEdge>((e) => ({
id: e.id,
source: e.source,
target: e.target,
sourceHandle: e.sourceHandle ?? null,
label: typeof e.label === 'string' ? e.label : '',
})),
}
}
// -------------------------------------------------------------------------
/**
* 一轮 Copilot 对话。
*
* 以前操作流是用完即弃的——直接改画布,只在浮条上留一句 lastOp。那意味着
* 生成结束后,"它为什么这么建"这件事就没了:画布上是结果,过程不可回看。
* 侧栏要显示"它大致在想什么、动了哪些节点",就得把操作流本身留下来。
*/
export interface CopilotTurn {
id: string
instruction: string
/** 原始操作流,交给 decodeCopilot 翻译。thinking 在写入时就已合并 */
ops: CopilotOp[]
phase: 'running' | 'done' | 'error'
explanation: string
error: string
/** 在现有的图上改(true),还是从头生成(false) */
useBase?: boolean
/** 助手只回了一句话、没有改图(op=reply)。卡片按 Markdown 渲染它 */
reply?: string
/**
* 这一轮对画布做了什么。phase 只说流程走没走完,说不清画布变没变:
* - applied 收到 final,画布改了(diff 里是改了什么)
* - answered 助手回了一句话,画布没动
* - unchanged 走完了,但画布一处都没变(没收到 final 的流、改了个寂寞)
* - reverted 停止、失败或断流,已经退回这一轮之前(⇧⌘Z 能找回半成品)
*/
outcome?: 'applied' | 'answered' | 'unchanged' | 'reverted'
/** 这一轮改了哪些节点。回执「已应用 N 处改动」和逐项查看都用它 */
diff?: GraphDiff
/** final 里的问题。code === 'unknown_node_type' 的是「少了一步」:模型写了不存在的类型 */
issues?: CopilotIssue[]
/** 服务端自查的结论;repairing 时带第几轮 */
check?: {
status: CopilotCheckOp['status']
/**
* 拼好的一行一条(带节点名):「再修一次」原样交回模型。线上来的是 CopilotCheckEntry
* (对象或老会话的字符串),对象版在 items 里
*/
issues: string[]
/**
* 同一批问题原样的对象(后端给的 {level, node_id, field, code}),和 issues 一一对应。
* 「定位」要落到检查器里具体那一栏(循环的条件、成员的工具),拼好的字认不出来。
* 老会话、老后端给的是字符串,那几条这里 node_id / field 为空
*/
items?: CopilotIssue[]
round?: number
repaired?: number
message?: string
/** 自查时发现的工具被删(tools_dropped)。不挡运行,但要在这一步说出来 */
warnings?: string[]
}
/** 这一轮开始前打的撤销点。还在栈顶时「撤销这次」直接撤它 */
checkpoint?: number
/** 提交的时刻(毫秒)。助手流的头部据此走实时计时,不用等 3 秒一次的心跳 */
startedAt?: number
/**
* 这一轮改了哪些节点、成员的工具绑定。画布上看不出来(节点还在),跑起来才发现查不了库,
* 所以回执要明说。取后端 final.tool_changes;老后端不给时前端自己比对前后两张图
*/
toolChanges?: ToolChange[]
/**
* 工具集合变小、而这一轮的指令没让删的提醒(check.warnings 和 final.issues 里
* code === 'tools_dropped' 的,去重)。单独放:和「成果字段可能为空」这类普通校验提示
* 混在一起,最要紧的这句就淹没了
*/
toolWarnings?: CopilotIssue[]
}
export interface CopilotIssue {
level: 'error' | 'warning'
message: string
node_id?: string | null
code?: string
type?: string
field?: string | null
}
/**
* 自查问题的一条。后端现在给 {level, node_id, edge_id, message, field, code?};老会话里存的、
* 老后端给的是一行字,那种 node_id / field 为空,照样拼得进「再修一次」
*/
export function checkIssueOf(x: CopilotCheckEntry | unknown): CopilotIssue {
if (typeof x === 'string') return { level: 'error', message: x, node_id: null, field: null }
const o = (x && typeof x === 'object' ? x : {}) as Record<string, unknown>
return {
level: o.level === 'warning' ? 'warning' : 'error',
message: typeof o.message === 'string' ? o.message : JSON.stringify(x),
node_id: typeof o.node_id === 'string' && o.node_id ? o.node_id : null,
field: typeof o.field === 'string' && o.field ? o.field : null,
...(typeof o.code === 'string' ? { code: o.code } : {}),
}
}
/**
* 画布此刻为什么改不了:
* - copilot:助手正在改它,这时候的手动编辑会被它的最终结果悄悄覆盖;
* - formal:正式运行在跑已发布的不可变版本,此刻改图既改不了它,还会让事件对到
* 已经被删掉的节点上。画布那边(FlowCanvas)按同一个条件写 data-readonly
*/
export type EditLock = 'copilot' | 'formal' | null
const formalRunning = (s: Pick<StudioState, 'runPhase' | 'trace' | 'run'>): boolean =>
isActivePhase(s.runPhase) && (s.trace.runClass ?? s.run?.run_class) === 'formal'
export function editLockOf(s: Pick<StudioState, 'copilot' | 'runPhase' | 'trace' | 'run'>): EditLock {
if (s.copilot.active) return 'copilot'
return formalRunning(s) ? 'formal' : null
}
/** 改图入口被拦下时说的话。检查器、节点库、快捷键都用这一份 */
export const EDIT_LOCK_TEXT: Record<Exclude<EditLock, null>, string> = {
copilot: '助手正在修改此工作流,请等待完成或先停止助手',
formal: '正式运行进行中,画布为只读:本次运行使用已发布的固定版本,请在运行结束后编辑',
}
/** 组件里订阅锁:只在锁的原因变了时重渲染 */
export const useEditLock = (): EditLock => useStudio(editLockOf)
/**
* 一键升级为可追溯结构:预览摆着之后「应用」的那一段。saving 存草稿中;stale 预览之后画布又改过;
* locked 画布锁着没落下去(unsaved:已经落到画布上、要存时锁着);failed 落到画布上了、没存上
*/
export type UpgradeApply =
| { status: 'saving' | 'stale' }
| { status: 'locked'; why: string; unsaved?: boolean }
| { status: 'failed'; error: unknown }
/** 升级已经落到画布上、没存上:存失败,或者要存时画布锁着。面板给「重试保存」「放弃」,平常的保存存上了就清掉 */
export function upgradeUnsaved(a: UpgradeApply | undefined): boolean {
return a?.status === 'failed' || (a?.status === 'locked' && !!a.unsaved)
}
/**
* 升级预览的状态。seq 是第几次请求:面板据此认出「又开了一次预览」(切回校验页、滚到眼前)。
* base 是发请求那一刻的图(后端没给逐项改动时按它和升级后的图自己列),sig 是它的内容签名
*/
export type UpgradeFlow =
| { status: 'loading'; assist: boolean; seq: number }
| { status: 'ready'; assist: boolean; seq: number; result: UpgradeResult; sig: string; base: GraphSpec; apply?: UpgradeApply }
| { status: 'error'; assist: boolean; seq: number; error: unknown }
| { status: 'unsupported'; assist: boolean; seq: number }
/** 两张图差在哪。只看节点的名字和配置,挪位置不算改动 */
export interface GraphDiff {
added: string[]
removed: string[]
changed: string[]
edgesAdded: number
edgesRemoved: number
/** 一共几处:回执里的 N */
total: number
}
/** 自查的 warnings 和 final.issues 里是同样的几条:按节点、字段、文字去重 */
function dedupeIssues(list: CopilotIssue[]): CopilotIssue[] {
const seen = new Set<string>()
return list.filter((i) => {
const key = `${i.node_id ?? ''}|${i.field ?? ''}|${i.message}`
if (seen.has(key)) return false
seen.add(key)
return true
})
}
// 只留最近几轮。画布只反映最后一次生成的结果,更早的轮次是参考而不是现状,
// 无上限地攒着只会把内存和滚动条都撑坏。
const COPILOT_TURN_LIMIT = 10
/**
* 后端每次改图带上最近几轮问答(conversations.py 的 HISTORY_TURNS)。界面上要说清
* 「模型此刻记得几轮」,不能显示一片空白而模型脑子里装着前 6 轮。
*/
export const COPILOT_HISTORY_TURNS = 6
const edgeSig = (e: { source: string; target: string; sourceHandle?: string | null }): string =>
`${e.source}>${e.target}:${e.sourceHandle ?? ''}`
export function diffGraphs(
before: { nodes: FlowNode[]; edges: Edge[] }, after: { nodes: FlowNode[]; edges: Edge[] },
): GraphDiff {
const old = new Map(before.nodes.map((n) => [n.id, n]))
const now = new Map(after.nodes.map((n) => [n.id, n]))
const added = after.nodes.filter((n) => !old.has(n.id)).map((n) => n.id)
const removed = before.nodes.filter((n) => !now.has(n.id)).map((n) => n.id)
const changed = after.nodes.filter((n) => {
const o = old.get(n.id)
return !!o && o !== n && (o.data.label !== n.data.label
|| o.data.nodeType !== n.data.nodeType || configSig(o.data.config) !== configSig(n.data.config))
}).map((n) => n.id)
const oldEdges = new Set(before.edges.map(edgeSig))
const newEdges = new Set(after.edges.map(edgeSig))
const edgesAdded = [...newEdges].filter((x) => !oldEdges.has(x)).length
const edgesRemoved = [...oldEdges].filter((x) => !newEdges.has(x)).length
return {
added, removed, changed, edgesAdded, edgesRemoved,
total: added.length + removed.length + changed.length + edgesAdded + edgesRemoved,
}
}
// -------------------------------------------------------------------------
// 撤销栈
// -------------------------------------------------------------------------
/**
* 撤销栈里的一格:改动**之前**画布的样子,外加这是哪一步。
*
* 只存节点和边的引用,不深拷贝:store 里的数组和节点对象从来都是换新的、不原地改,
* 所以旧引用本身就是一份不会再变的快照。50 步的代价只是 50 组指针。
* 运行态(runtime、events、trace)不进来——撤销的是编辑,不是运行结果。
*/
export interface HistoryEntry {
id: number
label: string
nodes: FlowNode[]
edges: Edge[]
at: number
/** 合并键:同一个键在窗口期内连续提交只算一步(连续打字、一次删除里的节点和边) */
key?: string
}
const HISTORY_LIMIT = 50
/** 同一个字段连续输入,停顿不超过这么久就算同一步 */
const TYPING_MERGE_MS = 1200
let historySeq = 0
/** 拖动开始前的样子。拖动中每一帧都有 position 变化,只在松手时记一步 */
let dragOrigin: { nodes: FlowNode[]; edges: Edge[] } | null = null
/**
* 正在进行的那一轮助手生成。stop 按「停止」收尾(画布退回这一轮之前);
* abandon 只掐流不动画布——换图时用,那时候画布已经是另一张图了
*/
let activeTurn: { id: string; stop: () => void; abandon: () => void } | null = null
/** 复制出来的节点和它们之间的边。放在模块里:换一张图也能粘过去 */
let clipboard: { nodes: FlowNode[]; edges: Edge[] } | null = null
/**
* 助手收尾时节点从流式期间的临时位置滑到排版位置。每次撤销、重做、换图、新开一轮
* 都自增:正在滑的那一次看到对不上就停,不会把撤回去的节点又拽回来
*/
let glideSeq = 0
const GLIDE_MS = 320
/** 超过这么多节点就直接落位:逐帧重算走线的代价随节点数涨,大图上一卡一卡的反而像出错 */
const GLIDE_MAX_NODES = 60
const reducedMotion = (): boolean => {
try {
return window.matchMedia('(prefers-reduced-motion: reduce)').matches
} catch {
return false
}
}
/** 卡片默认尺寸:量到之前按这个避让 */
const CARD_W = 238
const CARD_H = 96
const boxOf = (n: FlowNode) => ({
x: n.position.x, y: n.position.y,
w: n.measured?.width ?? CARD_W, h: n.measured?.height ?? CARD_H,
})
/**
* 从 anchor(卡片左上角)开始由近到远找一块空地,不压住任何已有节点。
*
* 以前调色板点击添加固定落在流坐标 (220~380, 160~360) 的随机点,和视口无关,
* 实测会叠在已有节点上;每加一个节点都得先找它在哪、再把它拖开。
*/
function freeSpot(
nodes: FlowNode[], anchor: { x: number; y: number }, size = { w: CARD_W, h: CARD_H },
): { x: number; y: number } {
const boxes = nodes.map(boxOf)
const gap = 24
const free = (x: number, y: number) => boxes.every((b) =>
x + size.w + gap <= b.x || b.x + b.w + gap <= x || y + size.h + gap <= b.y || b.y + b.h + gap <= y)
const stepX = size.w + 40
const stepY = size.h + 30
for (let ring = 0; ring < 9; ring++) {
const cells: [number, number][] = []
for (let i = -ring; i <= ring; i++) {
for (let j = -ring; j <= ring; j++) {
if (Math.max(Math.abs(i), Math.abs(j)) === ring) cells.push([i, j])
}
}
// 同一圈里先试竖直方向:横向是数据流的方向,往下摆不容易挡住下游
cells.sort((a, b) => (Math.abs(a[0]) * 2 + Math.abs(a[1])) - (Math.abs(b[0]) * 2 + Math.abs(b[1])))
for (const [i, j] of cells) {
const x = anchor.x + i * stepX
const y = anchor.y + j * stepY
if (free(x, y)) return { x: Math.round(x), y: Math.round(y) }
}
}
return anchor
}
/** 整张图的包围盒中心。没有视口信息时(画布还没挂上)用它当落点 */
function centerOf(nodes: FlowNode[]): { x: number; y: number } {
if (!nodes.length) return { x: 240, y: 200 }
const boxes = nodes.map(boxOf)
const x0 = Math.min(...boxes.map((b) => b.x))
const y0 = Math.min(...boxes.map((b) => b.y))
const x1 = Math.max(...boxes.map((b) => b.x + b.w))
const y1 = Math.max(...boxes.map((b) => b.y + b.h))
return { x: (x0 + x1) / 2, y: (y0 + y1) / 2 }
}
/** 节点的选中标记跟 selectedId 走。只换真的变了的那几个对象 */
function withSelection(nodes: FlowNode[], ids: Set<string>): FlowNode[] {
let changed = false
const next = nodes.map((n) => {
const want = ids.has(n.id)
if (!!n.selected === want) return n
changed = true
return { ...n, selected: want }
})
return changed ? next : nodes
}
/** 撤销回来的快照:拖动中、选中这些交互态不跟着回来 */
function restoredNodes(nodes: FlowNode[], selectedId: string | null): FlowNode[] {
return nodes.map((n) => (n.dragging || !!n.selected !== (n.id === selectedId)
? { ...n, dragging: false, selected: n.id === selectedId }
: n))
}
/** 和上次保存的比。撤销回保存时的样子,「未保存」应当消失 */
const graphSig = (nodes: FlowNode[], edges: Edge[]): string => JSON.stringify(toGraph(nodes, edges))
/**
* 新节点的默认配置里写着 {{ input.question }}。这张图的入口字段不一定叫 question
* (⑥ 的入口是 goal),照抄就是一个现成的「引用不到」错误。换成真实的第一个字段。
*/
function adaptDefaults(config: Record<string, any>, nodes: FlowNode[]): Record<string, any> {
const entry = nodes.find((n) => n.data.nodeType === 'input')
const first = entry?.data.config?.fields?.[0]?.name
if (!first || first === 'question') return config
const swap = (v: any): any => {
if (typeof v === 'string') return v.replace(/input\.question\b/g, `input.${first}`)
if (Array.isArray(v)) return v.map(swap)
if (v && typeof v === 'object') return Object.fromEntries(Object.entries(v).map(([k, x]) => [k, swap(x)]))
return v
}
return swap(config)
}
/**
* 找出(或建出)这张图的 Copilot 会话。
*
* 画布的对话依附工作流:打开这张图就接着上次聊。之前连说两次"再加一个节点",
* 第二次并不知道第一次说了什么——base_graph 带的是图的**结果**,带不出
* "你刚才要我干什么",所以模型经常把上一条的意图又做一遍或者做反。
*
* 不进左侧列表:那边列的是"问题",这里是"改图指令",两种东西混在一个列表里
* 只会让两种都更难找。
*
* 没保存过的草稿(workflow 为空)没有会话——它还没有一个能挂历史的身份。
*/
async function ensureCanvasConversation(
workflowId: string, set: (partial: Partial<StudioState>) => void, get: () => StudioState,
): Promise<string | null> {
try {
const existing = await api.conversations.list('canvas', workflowId)
const id = existing[0]?.id
?? (await api.conversations.create({ kind: 'canvas', workflow_id: workflowId })).id
// 等的这会儿又换了一张图:这条会话不属于眼前的图了
if (get().workflow?.id !== workflowId) return null
set({ copilotConversationId: id })
// 把之前几轮取回来。模型每次改图都带着它们(后端 _history_section),界面上却一片
// 空白——用户看不见模型记得什么,点了「清空」也以为重新开始了
if (existing[0]?.turn_count) {
void api.conversations.get(id).then((detail) => {
if (get().copilotConversationId !== id) return
const past = (detail.turns ?? []).filter((t) => t.status !== 'running')
set({ copilotMemory: memoryOf(past) })
}).catch(() => undefined)
}
return id
} catch {
return null // 记不下来也不该挡着人改图
}
}
const memoryOf = (past: ConversationTurn[]): StudioState['copilotMemory'] => ({
past, total: past.length, turns: Math.min(past.length, COPILOT_HISTORY_TURNS),
})
/** 把画布上这一轮记进会话,下一条指令才接得上 */
function recordCanvasTurn(
conversationId: string | null,
instruction: string,
patch: { graph?: any; explanation?: string; answer?: string; status?: 'done' | 'error'; error?: string
/** 这一轮的查看记录(look §2.5.8):服务端下一轮据此写「上一轮查看过」 */
meta?: { looks: LookEvent[] } },
set?: (fn: (s: StudioState) => Partial<StudioState>) => void,
): void {
if (!conversationId) return
void api.conversations.startTurn(conversationId, instruction)
.then((turn) => api.conversations.patchTurn(conversationId, turn.id, patch))
.then((turn) => {
// 模型下一轮会带上它:记忆的轮数跟着涨,界面上的「参考前 N 轮」才是真话
set?.((s) => s.copilotConversationId === conversationId
? { copilotMemory: memoryOf([...s.copilotMemory.past, turn]) }
: {})
})
.catch(() => undefined)
}
interface StudioState {
workflow: Workflow | null
nodes: FlowNode[]
edges: Edge[]
selectedId: string | null
dirty: boolean
/** 校验出来的 error / warning。info 级的建议不在这里,在 advice */
issues: ValidationIssue[]
/**
* 校验给的建议(info 级,比如 evidence.upgrade_available「可以升级为可追溯结构」)。它们不是问题:
* 不点亮节点卡、不算进工具栏的计数,只在问题面板里给一个快速修复
*/
advice: ValidationIssue[]
/** 一键升级的预览和应用。换图时清掉 */
upgrade: UpgradeFlow | null
/** 这张图里有哪些变量:谁产出、谁引用。结构不变就不重新请求 */
variables: Variable[]
/** 变量层面的提示(含"产出了没人用"这类 info,不进 issues) */
varIssues: VarIssue[]
run: Run | null
/** 已落库的那些事件。llm.token / llm.thinking.delta 不进来:它们不落库,刷新后也不会回来 */
events: RunEvent[]
runtime: Record<string, NodeRuntime>
/** 此刻在流动的边:只指向正在执行的节点(等待审批的不算)。内容不变时沿用原数组 */
activeEdges: string[]
streaming: boolean
unsubscribe: (() => void) | null
/** 由事件推出的运行相位。变化时同步写回 run.status(waiting → interrupted) */
runPhase: RunPhase
/** 运行航迹:事件 → 航迹 → 投影(t)。画布、胶囊、时间轴、回放都读它 */
trace: Trace
/** 实时累加的用量(llm.end)。只用来显示;终态时以后端累计为准校正 */
usageLive: { tokensIn: number; tokensOut: number; costUsd: number }
/** 右栏步骤行悬停的节点。卡片用 s => s.hoveredNodeId === id 订阅,别订阅整个字段 */
hoveredNodeId: string | null
/** 请画布取景到某个节点;seq 每次 +1,同一个节点连点两次也能再触发 */
focusRequest: { id: string; seq: number } | null
/** 回放游标(毫秒时间戳)。null = 实时 */
replayAt: number | null
/** 跟随执行:画布跟着正在跑的节点走。用户手动平移后由画布关掉 */
follow: boolean
/** 当前高亮的变量血缘:谁产出、谁引用 */
lineage: { var: string; producers: string[]; consumers: string[] } | null
/**
* 发起(或接着跑)这次运行时画布的样子。卡片拿 configSig(当前 config) 和
* configs[id] 比,不一样就标"结果为旧配置";structure 对不上说明增删过节点或
* 连线,接着跑会被后端拒绝。看历史运行时是 null(不知道当时的画布)
*/
runSnapshot: { configs: Record<string, string>; structure: string } | null
/** 这张图的 Copilot 会话 id。一张图一条,用来让连续几条改图指令互相知情 */
copilotConversationId: string | null
/**
* 模型此刻记得的上下文。past 是这条会话里已经结束的轮次(包括打开这张图之前的),
* turns 是下一条指令会带上的轮数(最多 COPILOT_HISTORY_TURNS)。
* 「开始新对话」换一条会话,这里清零,模型的上下文才真的清零
*/
copilotMemory: { past: ConversationTurn[]; total: number; turns: number }
/** 这一轮助手最近动过的节点。画布可以据此跟随镜头、标出「下一步落在这」 */
copilotCursor: string | null
// ---- 编辑 ----
/** 撤销栈:每格是改动之前的画布。新改动清空 future */
past: HistoryEntry[]
future: HistoryEntry[]
/**
* 校验和变量分析的状态。以前分析失败被吞掉,issues 保持为空,工具栏照样说「可运行」;
* 首次分析回来之前也会先闪一下「可运行」。没校验过就不该给这个承诺
*/
analysis: 'idle' | 'pending' | 'ok' | 'failed'
analysisError: string | null
/**
* 画布视口中心的流坐标。由画布(FlowCanvas,ReactFlowProvider 在它里面)注册;
* 调色板点击添加、粘贴都落在这附近。没注册时为 null,退回图的中心
*/
getViewportCenter: (() => { x: number; y: number }) | null
/** 下次保存时写进版本说明的话。恢复旧版本时是「回滚到 vN」 */
pendingNote: string
copilot: {
active: boolean
lastOp: string
explanation: string
error: string
/** 出错时「怎么办」(后端 error 操作的 hint)。Composer 的错误条和问数据页一样摊开它 */
errorHint: string
/** 出错时的原始报错(后端 error 操作的 detail),折叠在技术细节里 */
errorDetail: string
model: string
// 从提交到第一个操作之间有 5~30 秒,得让用户看见这段在发生什么
phase: 'connecting' | 'planning' | 'looking' | 'building' | 'wiring' | 'finalizing' | 'repairing' | ''
thinking: string // 模型的思考原文(只有支持 thinking 的模型有)
elapsedMs: number
lastInstruction: string // 失败后"用同一需求重试"要用
lastUseBase: boolean
}
copilotNew: string[]
copilotTurns: CopilotTurn[]
cancelCopilot: (() => void) | null
/** 每次 +1 = 请求画布重新取景。整张图换过坐标之后不重新取景,人会盯着一片空白 */
fitRequest: number
// actions
/** 打开一张工作流。传 null 是卸下眼前这张:它被删了、又没有别的可换 */
load: (workflow: Workflow | null) => void
/** 整张换掉(自动排版)。画布锁着时不换、返回 false:调用方别再报「已换好」 */
setGraph: (graph: GraphSpec) => boolean
/**
* 发布前修复的预览落到画布上:记一步撤销(label),节点的位置和选中照旧、不重新取景——
* 改的只是几个配置项,镜头一跳人就找不到刚才在看的节点了。锁着时不落、返回 false
*/
applyFixes: (graph: GraphSpec, label: string) => boolean
/**
* 一键升级:拿画布上此刻的图(连同全图默认)去要一份预览,只读。画布锁着时不要、说清为什么。
* assist 时后端再交给 Copilot 改语义层
*/
previewUpgrade: (opts?: { assist?: boolean }) => Promise<void>
/**
* 应用预览:预览之后画布没改过才落(applyFixes,记一步撤销、全图默认照带),再走现有的保存存成草稿。
* 返回存上了没有
*/
applyUpgrade: () => Promise<boolean>
/** 升级已经落到画布上、没存上(存失败、或者要存时画布锁着):再存一次 */
retryUpgradeSave: () => Promise<boolean>
discardUpgrade: () => void
onNodesChange: (changes: NodeChange[]) => void
onEdgesChange: (changes: EdgeChange[]) => void
onConnect: (conn: Connection) => void
/** 不给位置时落在视口中心附近的空地上。新节点自动选中 */
addNode: (type: NodeType, position?: { x: number; y: number }) => void
updateNode: (id: string, patch: { label?: string; config?: Record<string, any> }) => void
removeNode: (id: string) => void
duplicateNode: (id: string) => void
/** 复制选中的节点(多选时全部)连同它们之间的边,挨着原位放。返回复制了几个 */
duplicateSelection: () => number
/** ⌘C:记下选中的节点和它们之间的边。返回几个 */
copySelection: () => number
/** ⌘V:换新 id 粘到视口中心附近。返回几个 */
pasteClipboard: () => number
selectAll: () => void
select: (id: string | null) => void
/** note 不传时用 pendingNote(恢复旧版本时自动填的那句) */
save: (note?: string) => Promise<void>
validate: () => Promise<void>
analyzeNow: () => Promise<void>
undo: () => void
redo: () => void
/** 版本历史里「恢复这一版」:作为一次可撤销的改动放上画布,保存后才生效 */
restoreVersion: (version: number, graph: GraphSpec) => void
/** 悬停变量:算出谁产出、谁引用,写进 lineage。null 清掉 */
traceVariable: (path: string | null) => void
startRun: (input: Record<string, any>) => Promise<Run | null>
startFormalRun: (input: Record<string, any>) => Promise<Run | null>
/**
* 开始一轮助手改图。返回开没开始:正式运行期间画布只读,会被拦下(并提示为什么),
* 输入框据此决定要不要清掉用户刚写的那句
*/
runCopilot: (instruction: string, useBase: boolean, model?: string | null) => boolean
/** 停掉这一轮,画布退回这一轮之前(半成品进 future,⇧⌘Z 能找回来) */
stopCopilot: () => void
retryCopilot: () => void
/** 旧名字:现在等于 newCopilotConversation。只清界面不换会话,模型照样带着旧上下文 */
clearCopilot: () => void
/** 换一条新会话:模型的上下文真的清零。旧会话保留在后端 */
newCopilotConversation: () => Promise<void>
/**
* 让助手再修一次:把这一轮自查剩下的问题、少掉的步骤(没给 turnId 时用最后一轮;
* 都没有就用画布当前的校验错误)拼成指令,在现有的图上改
*/
repairWithCopilot: (turnId?: string) => void
/** 撤销这一轮助手的改动。只有它还在撤销栈顶时能撤,返回撤没撤 */
undoCopilotTurn: (turnId: string) => boolean
attachRun: (runId: string) => Promise<void>
/** 失败的运行从断点接着跑,把画布上改过的配置一起带过去 */
continueRun: () => Promise<void>
/** 失败时抛出(多半是 409:运行其实已经不在跑了),调用方负责提示;同时会对一次账 */
stopRun: () => Promise<void>
/** 清掉这次运行的一切痕迹,画布回到编辑态 */
clearRun: () => void
applyEvent: (event: RunEvent) => void
/** GET /runs/{id} 对一次账:漏了终态事件(断线、服务被强杀)时靠它收尾 */
reconcileRun: () => Promise<void>
setHoveredNode: (id: string | null) => void
focusNode: (id: string) => void
setReplayAt: (at: number | null) => void
setFollow: (follow: boolean) => void
setLineage: (lineage: StudioState['lineage']) => void
}
const EMPTY_RUNTIME: NodeRuntime = { status: 'idle' }
// -------------------------------------------------------------------------
// 运行态:事件 → 航迹 → store 的其余字段
// -------------------------------------------------------------------------
const ZERO_USAGE: StudioState['usageLive'] = { tokensIn: 0, tokensOut: 0, costUsd: 0 }
export const configSig = (config: Record<string, any> | undefined): string =>
JSON.stringify(config ?? {})
/** 骨架:节点 id 和连线。和后端 continue 判断"同一张图"的口径一致——只看结构不看配置 */
export function structureSig(nodes: FlowNode[], edges: Edge[]): string {
const ids = nodes.map((n) => n.id).sort().join(',')
const links = edges.map((e) => `${e.source}>${e.target}:${e.sourceHandle ?? ''}`).sort().join(',')
return `${ids}|${links}`
}
function snapshotOf(nodes: FlowNode[], edges: Edge[]): StudioState['runSnapshot'] {
return {
configs: Object.fromEntries(nodes.map((n) => [n.id, configSig(n.data.config)])),
structure: structureSig(nodes, edges),
}
}
/** 开始一次新运行、换一条运行、清掉结果时要一起清的运行态 */
function runReset(): Partial<StudioState> {
return {
events: [], runtime: {}, activeEdges: [], trace: emptyTrace(), usageLive: ZERO_USAGE,
runPhase: 'idle', replayAt: null, follow: true, runSnapshot: null,
}
}
function seedTrace(run: Run): Trace {
return {
...emptyTrace(),
phase: run.status === 'queued' ? 'queued' : 'idle',
runClass: run.run_class,
}
}
/** 推导出来的几种(排队、阻断、没走到)不是 runtime 的状态,卡片从航迹读 */
function runtimeStatusOf(state: NodeState): NodeRuntime['status'] {
switch (state) {
case 'idle': case 'queued': case 'blocked': case 'unreached': return 'idle'
default: return state
}
}
const sameIds = (a: string[], b: string[]): boolean =>
a.length === b.length && a.every((x, i) => x === b[i])
const num = (v: unknown): number | undefined =>
typeof v === 'number' && Number.isFinite(v) ? v : undefined
/**
* 一条事件(或一次对账)落进航迹之后,把航迹派生到 store 的其余字段上:
* 节点 runtime 的状态、协作团队的收尾、活跃边、相位(写回 run.status)、
* 实时用量、streaming。applyEvent 和对账走同一条路,免得两处收尾口径不一。
*
* runtime 由调用方先复制好(applyEvent 还要往里写正文、工具调用这些)。
*/
function advance(
s: StudioState, runtime: Record<string, NodeRuntime>, event: RunEvent,
): Partial<StudioState> {
const folded = foldEvent(s.trace, event)
if (folded === s.trace) return {}
const graph = { nodes: s.nodes, edges: s.edges }
let trace = isSettled(folded.phase) ? finalizeTrace(folded, graph) : applyDerived(folded, graph)
// 客户端和服务端的时钟差(见 liveAt)。补发的历史不算:它们的 ts 早就过去了
const ts = num(event.ts)
if (ts != null && !event.replay && event.type !== 'stream.end') {
const skew = Date.now() - ts * 1000
if (trace.skewMs == null || skew < trace.skewMs) trace = { ...trace, skewMs: skew }
}
// 节点状态只有航迹一个来源;runtime 上的正文、工具调用这些由 applyEvent 管
for (const [id, n] of Object.entries(trace.nodes)) {
const cur = runtime[id]
const status = runtimeStatusOf(n.state)
if (!cur && status === 'idle') continue
if (cur?.status !== status || cur?.iteration !== n.iteration) {
runtime[id] = { ...(cur ?? EMPTY_RUNTIME), status, iteration: n.iteration }
}
}
// 协作团队的"进行中"随结局一起收:只收节点的话,矩阵里那几行会一直转
const ending = endingOf(event, s.trace.book.awaiting)
if (ending) {
for (const [id, r] of Object.entries(runtime)) {
if (!r.team) continue
const team = settleTeam(r.team, ending)
if (team !== r.team) runtime[id] = { ...r, team }
}
}
const edges = isSettled(trace.phase) ? [] : activeEdgesOf(trace, graph)
const activeEdges = sameIds(edges, s.activeEdges) ? s.activeEdges : edges
let run = s.run
if (run && trace.phase !== s.runPhase) {
const status = runStatusOf(trace.phase)
if (status && status !== run.status) run = { ...run, status }
}
const type = String(event.type)
if (run && (type === 'run.finished' || type === 'run.failed' || type === 'run.cancelled')) {
// 以前 run 一直是 POST /runs 返回的 queued 快照:失败了"接着跑"出不来,
// 底栏的用量永远是空的。终态事件里有的都并进去,完整的再由对账补
const d = event.data ?? {}
const timing = d.timing ?? {}
run = {
...run,
...(type === 'run.failed' && d.error ? { error: String(d.error) } : {}),
...(type === 'run.finished' && d.output ? { output: d.output } : {}),
usage: {
...run.usage,
...(num(d.duration_ms) != null ? { duration_ms: d.duration_ms } : {}),
...(d.usage ?? {}),
...(num(timing.wall_ms) != null ? { wall_ms: timing.wall_ms } : {}),
...(num(timing.active_ms) != null ? { active_ms: timing.active_ms } : {}),
...(num(timing.wait_ms) != null ? { wait_ms: timing.wait_ms } : {}),
},
}
}
const u = s.usageLive
const usageLive = u.tokensIn === trace.tokensIn && u.tokensOut === trace.tokensOut
&& u.costUsd === trace.costUsd
? u : { tokensIn: trace.tokensIn, tokensOut: trace.tokensOut, costUsd: trace.costUsd }
// 终态、挂起就不再"在跑"。恢复后事件又来了(别处点了接着跑)而订阅还在,就重新亮起
const streaming = isSettled(trace.phase) ? false
: isActivePhase(trace.phase) && s.unsubscribe ? true : s.streaming
return { runtime, trace, activeEdges, runPhase: trace.phase, run, usageLive, streaming }
}
/** 每接上一条事件流自增。对账回来时对不上,说明在途时又开了新的流(审批恢复、接着跑) */
let streamEpoch = 0
/**
* 对账:GET /runs/{id},必要时查一下有没有待审批,把结论当成一条合成的
* stream.end 折进航迹。
*
* 收敛不能只靠事件:服务被强杀时连 server_shutdown 都不会发,WS 会一直重连;
* 用户点停止撞上 409,也说明它其实早就不在跑了。这时候画布上的"运行中"
* 全是假的,得问后端一次。顺带拿到完整的成果和后端累计的用量。
*/
async function reconcile(
runId: string, set: (partial: Partial<StudioState>) => void, get: () => StudioState,
): Promise<void> {
// 请求在途时用户可能已经批了、点了接着跑:事件又动了,或者接上了新的事件流。
// 这时候手上的快照是旧的,折进去会把刚恢复的运行又收成挂起 / 失败(续跑、恢复
// 不换 run id,光比 id 拦不住)。直接作废,新的那条流结束时会再对一次账
const seq0 = get().trace.lastSeq
const epoch0 = streamEpoch
let fresh: Run
try {
fresh = await api.runs.get(runId)
} catch {
return
}
let pending: boolean | undefined
if (fresh.status === 'interrupted') {
try {
// 按 run_id 查:全局列表只给最新的 100 条,更早的那条审批会被当成没有
pending = (await api.approvals.list({ run_id: runId, status: 'pending' })).length > 0
// 没有待审批时再读一次状态。批准和"恢复成 running"是同一个事务落库的:
// 第一次读到 interrupted 之后有人批了,这里读到的就是 running,而不是挂起
if (!pending) fresh = await api.runs.get(runId)
} catch {
/* 查不到就按事件推的算 */
pending = undefined
}
}
const s = get()
if (s.run?.id !== runId || s.trace.lastSeq !== seq0 || streamEpoch !== epoch0) return
// 结局已经由事件收过的话 advance 什么都不改,这里只把后端那份 run 换上
const next = advance(s, { ...s.runtime }, {
seq: 0, type: 'stream.end', node_id: null, ts: s.trace.book.clock / 1000,
data: { status: fresh.status, ...(pending != null ? { pending } : {}) },
})
let trace = next.trace ?? s.trace
const u = fresh.usage ?? {}
if (isTerminal(trace.phase)) {
// 后端累计的才是权威总数(老后端的 agent / 协作调用不发 llm.end,实时累加会少)
const tokensIn = num(u.input_tokens) ?? trace.tokensIn
const tokensOut = num(u.output_tokens) ?? trace.tokensOut
const costUsd = num(u.cost_usd) ?? trace.costUsd
if (tokensIn !== trace.tokensIn || tokensOut !== trace.tokensOut || costUsd !== trace.costUsd) {
trace = { ...trace, tokensIn, tokensOut, costUsd }
}
}
const live = s.usageLive
set({
...next,
trace,
usageLive: live.tokensIn === trace.tokensIn && live.tokensOut === trace.tokensOut
&& live.costUsd === trace.costUsd
? live : { tokensIn: trace.tokensIn, tokensOut: trace.tokensOut, costUsd: trace.costUsd },
run: { ...fresh, status: runStatusOf(trace.phase) ?? fresh.status },
})
}
// 300ms:比连续打字的间隔长,比"停下来看结果"的感知阈值短
const ANALYZE_DEBOUNCE_MS = 300
let analyzeTimer: ReturnType<typeof setTimeout> | null = null
/** 每次发起分析自增。回来时对不上就说明图又改过了,这个结果已经过期 */
let analyzeEpoch = 0
/** 上一次算变量表时的结构签名,没变就不重复请求 */
let lastVarSignature = ''
/**
* "有哪些变量"只取决于图的结构,不取决于文案。
*
* 节点 id、类型、assign_to、入口字段名——只有这些变了,变量集合才会变。
* 改 prompt 里的一个字不该触发一次变量分析。
*/
function varSignature(nodes: FlowNode[]): string {
return nodes
.map((n) => {
const cfg = n.data.config ?? {}
const fields = (cfg.fields ?? []).map((f: any) => f?.name ?? '').join(',')
return `${n.id}:${n.data.nodeType}:${cfg.assign_to ?? ''}:${fields}`
})
.sort()
.join('|')
}
async function runAnalysis(
set: (partial: Partial<StudioState>) => void, get: () => StudioState, force = false,
): Promise<void> {
const { nodes, edges } = get()
if (!nodes.length) {
set({ issues: [], advice: [], variables: [], varIssues: [], analysis: 'ok', analysisError: null })
return
}
const epoch = ++analyzeEpoch
const graph = toGraph(nodes, edges)
const signature = varSignature(nodes)
const needVars = force || signature !== lastVarSignature
try {
const [validation, vars] = await Promise.all([
api.workflows.validate(graph),
needVars ? api.workflows.variables(graph) : Promise.resolve(null),
])
// 图在请求飞行期间又改了,这份结果已经不对应眼前的图——丢掉,
// 别用旧答案覆盖新答案(校验结果闪回是最难查的那种 UI bug)
if (epoch !== analyzeEpoch) return
// 建议(info)另放:节点卡、检查器、运行按钮只认 error / warning,混进来会被当成提示点亮
const all = validation.issues ?? []
set({
issues: all.filter((i) => i.level !== 'info'), advice: all.filter((i) => i.level === 'info'),
analysis: 'ok', analysisError: null,
})
if (vars) {
lastVarSignature = signature
set({ variables: vars.variables ?? [], varIssues: vars.issues ?? [] })
}
} catch (e) {
// 分析失败不挡编辑,但也不能装作校验过了:工具栏要说「校验不可用」,
// 而不是拿着空的 issues 说「可运行」
if (epoch !== analyzeEpoch) return
const h = humanizeError(e)
set({ analysis: 'failed', analysisError: h.reason ? `${h.title}:${h.reason}` : h.title })
// 变量表签名没记下:恢复之后要重新算一次,而不是以为已经算过了
lastVarSignature = ''
}
}
type SetFn = (partial: Partial<StudioState> | ((s: StudioState) => Partial<StudioState>)) => void
/**
* 记一步:把此刻的画布压进撤销栈,然后调用方再改。
*
* key + mergeMs 用来把「一件事」合成一步:连续打字(同一个节点同一组字段)、
* 一次删除(React Flow 先发边的 remove,再发节点的 remove,同一个 tick 里)。
*/
function commit(
set: SetFn, get: () => StudioState, label: string,
opts: { key?: string; mergeMs?: number; nodes?: FlowNode[]; edges?: Edge[] } = {},
): HistoryEntry | null {
const s = get()
const now = Date.now()
const top = s.past[s.past.length - 1]
if (opts.key && top?.key === opts.key && now - top.at < (opts.mergeMs ?? TYPING_MERGE_MS)) {
// 同一步的延续:只续上时间窗,快照还是这一串开始之前的那份
set({ past: [...s.past.slice(0, -1), { ...top, at: now }], future: [] })
return null
}
const entry: HistoryEntry = {
id: ++historySeq, label, at: now, key: opts.key,
nodes: opts.nodes ?? s.nodes, edges: opts.edges ?? s.edges,
}
set({ past: [...s.past, entry].slice(-HISTORY_LIMIT), future: [] })
return entry
}
/** 画布锁着:助手正在改,或者正式运行在跑(见 editLockOf) */
const locked = (get: () => StudioState) => editLockOf(get()) !== null
/** 撤销 / 重做之后:选中的节点没了就收起检查器,未保存标记按内容重算 */
function afterJump(set: SetFn, get: () => StudioState, nodes: FlowNode[], edges: Edge[]) {
glideSeq++
const sel = get().selectedId
const selectedId = sel && nodes.some((n) => n.id === sel) ? sel : null
set({
nodes: restoredNodes(nodes, selectedId), edges, selectedId,
dirty: graphSig(nodes, edges) !== savedSig,
})
void get().validate()
}
/** 在途的升级预览请求:换图、放弃、再开一次时掐掉 */
let upgradeCtl: AbortController | null = null
let upgradeSeq = 0
/**
* 升级已经落到画布上,存草稿。和页面自己的保存同一套规矩:画布锁着(助手在改、正式运行在跑)不存;
* 恢复旧版本留下的「回滚到 vN」不能被这一句盖掉,两句接着写
*/
async function saveUpgrade(set: SetFn, get: () => StudioState): Promise<boolean> {
const u = get().upgrade
if (u?.status !== 'ready') return false
const lock = editLockOf(get())
if (lock) {
set({ upgrade: { ...u, apply: { status: 'locked', why: EDIT_LOCK_TEXT[lock], unsaved: true } } })
return false
}
// 还没存成工作流的画布(问数据页「在画布里打开」的草稿)没有地方存:落到画布上就算完,照实说还没保存
if (!get().workflow) {
set({ upgrade: null })
toast.info(UPGRADE_TEXT.appliedDraft, { key: 'studio:upgrade' })
return false
}
set({ upgrade: { ...u, apply: { status: 'saving' } } })
const pending = get().pendingNote.trim()
try {
await get().save(pending ? `${pending};${UPGRADE_TEXT.saveNote}` : UPGRADE_TEXT.saveNote)
} catch (error) {
const cur = get().upgrade
if (cur?.status === 'ready' && cur.seq === u.seq) set({ upgrade: { ...cur, apply: { status: 'failed', error } } })
return false
}
if (get().upgrade?.seq === u.seq) set({ upgrade: null })
toast.ok(UPGRADE_TEXT.applied(get().workflow?.version), { key: 'studio:upgrade' })
return true
}
/** 上次保存(或打开)时的图。撤销回这个样子时「未保存」要消失 */
let savedSig = ''
/**
* 把一组节点从现在的位置滑到 targets,约 320ms,结束时 done()。
*
* 走的是 store 里的 position,不是给卡片加 CSS transform 过渡:走线由 buildRoutes 按
* store 里的坐标算,只动卡片的话线会先跳到终点、和卡片脱节,看着像渲染出错。每帧只
* 换真在动的那几个节点对象;量尺寸、选中这些别的变化照常进来,不会被这一帧盖掉
*/
function glide(
set: SetFn, get: () => StudioState, targets: Map<string, { x: number; y: number }>, done: () => void,
) {
const seq = ++glideSeq
const from = new Map<string, { x: number; y: number }>()
for (const n of get().nodes) {
const to = targets.get(n.id)
if (to && (n.position.x !== to.x || n.position.y !== to.y)) from.set(n.id, n.position)
}
if (!from.size) { done(); return }
const t0 = performance.now()
const frame = (now: number) => {
if (seq !== glideSeq) return
const k = Math.min(1, (now - t0) / GLIDE_MS)
const e = 1 - (1 - k) ** 3
set({
nodes: get().nodes.map((n) => {
const a = from.get(n.id)
const b = targets.get(n.id)
// 用户已经抓住它在拖:归他
if (!a || !b || n.dragging) return n
return { ...n, position: k >= 1 ? b : { x: a.x + (b.x - a.x) * e, y: a.y + (b.y - a.y) * e } }
}),
})
if (k < 1) requestAnimationFrame(frame)
else done()
}
requestAnimationFrame(frame)
}
/** 删掉的节点叫什么:toast 里要说出名字,「已删除 3 个节点」不如「已删除「查询销量」」具体 */
function deletedToast(get: () => StudioState, removed: FlowNode[]) {
if (!removed.length) return
const text = removed.length === 1
? `已删除「${removed[0].data.label || removed[0].id}」`
: `已删除 ${removed.length} 个节点`
toast(text, 'info', { key: 'studio:deleted', action: { label: '撤销', onClick: () => get().undo() } })
}
/**
* 把一组节点(和它们之间的边)换新 id 放进画布。复制粘贴、⌘D 共用。
* 整组平移到 anchor 附近一块不压住别人的空地,组内相对位置不变。
*/
function cloneInto(
set: SetFn, get: () => StudioState, src: { nodes: FlowNode[]; edges: Edge[] },
anchor: { x: number; y: number }, label: string,
): number {
if (!src.nodes.length || locked(get)) return 0
const { nodes, edges } = get()
const x0 = Math.min(...src.nodes.map((n) => n.position.x))
const y0 = Math.min(...src.nodes.map((n) => n.position.y))
const w = Math.max(...src.nodes.map((n) => n.position.x + (n.measured?.width ?? CARD_W))) - x0
const h = Math.max(...src.nodes.map((n) => n.position.y + (n.measured?.height ?? CARD_H))) - y0
const spot = freeSpot(nodes, anchor, { w, h })
const ids = new Map<string, string>()
const fresh: FlowNode[] = src.nodes.map((n) => {
const id = nextId(n.data.nodeType)
ids.set(n.id, id)
return {
id, type: 'card', selected: true,
position: { x: spot.x + n.position.x - x0, y: spot.y + n.position.y - y0 },
data: { ...n.data, config: structuredClone(n.data.config ?? {}) },
}
})
const links: Edge[] = src.edges
.filter((e) => ids.has(e.source) && ids.has(e.target))
.map((e) => {
const source = ids.get(e.source)!
const target = ids.get(e.target)!
return {
id: `e_${source}_${e.sourceHandle ?? ''}_${target}`, source, target,
sourceHandle: e.sourceHandle ?? null, targetHandle: e.targetHandle ?? null,
label: e.label, type: 'flow',
}
})
commit(set, get, label)
const selectedId = fresh.length === 1 ? fresh[0].id : null
set({
nodes: [...withSelection(nodes, new Set()), ...fresh],
edges: [...edges.map((e) => (e.selected ? { ...e, selected: false } : e)), ...links],
selectedId, dirty: true,
})
void get().validate()
return fresh.length
}
/** 选中的那几个:React Flow 的多选,没有就是检查器里开着的那一个 */
function selectionOf(s: StudioState): FlowNode[] {
const picked = s.nodes.filter((n) => n.selected)
if (picked.length) return picked
const one = s.nodes.find((n) => n.id === s.selectedId)
return one ? [one] : []
}
export const useStudio = create<StudioState>((set, get) => ({
workflow: null,
nodes: [],
edges: [],
selectedId: null,
dirty: false,
issues: [],
advice: [],
upgrade: null,
variables: [],
varIssues: [],
run: null,
events: [],
runtime: {},
activeEdges: [],
streaming: false,
unsubscribe: null,
runPhase: 'idle',
trace: emptyTrace(),
usageLive: ZERO_USAGE,
hoveredNodeId: null,
focusRequest: null,
replayAt: null,
follow: true,
lineage: null,
runSnapshot: null,
copilotConversationId: null,
copilotMemory: { past: [], total: 0, turns: 0 },
copilotCursor: null,
copilot: { active: false, lastOp: '', explanation: '', error: '', errorHint: '', errorDetail: '', model: '',
phase: '', thinking: '', elapsedMs: 0, lastInstruction: '', lastUseBase: false },
copilotNew: [],
copilotTurns: [],
cancelCopilot: null,
fitRequest: 0,
past: [],
future: [],
analysis: 'idle',
analysisError: null,
getViewportCenter: null,
pendingNote: '',
load: (workflow) => {
const { nodes, edges } = workflow ? toFlow(workflow.graph) : { nodes: [] as FlowNode[], edges: [] as Edge[] }
get().unsubscribe?.()
// 上一张图的生成还在跑的话先掐掉:它的操作流会落到这张图上
activeTurn?.abandon()
activeTurn = null
get().cancelCopilot?.()
dragOrigin = null
glideSeq++
graphExtras = extrasOf(workflow?.graph)
savedSig = graphSig(nodes, edges)
lastVarSignature = ''
// 上一张图的升级预览:套到这张图上就错了
upgradeCtl?.abort()
upgradeCtl = null
set({
workflow, nodes, edges, selectedId: null, dirty: false, issues: [], advice: [], upgrade: null,
// 变量表也清掉:不清的话切图后抽屉会先显示上一张图的变量
variables: [], varIssues: [], analysis: workflow ? 'pending' : 'idle', analysisError: null,
...runReset(), run: null, streaming: false, unsubscribe: null,
hoveredNodeId: null, focusRequest: null, lineage: null,
// 整张图换了,视角也要跟着换。不换的话打开另一张图看到的还是上一张的
// 那块空白——画布位置是视口的,不是图的
fitRequest: get().fitRequest + 1,
// 换了一张图,之前那些"我让它改成这样"就不再指向眼前这张图了
copilotTurns: [],
copilotNew: [],
copilotCursor: null,
copilot: { ...get().copilot, active: false, phase: '', thinking: '', lastOp: '', error: '',
errorHint: '', errorDetail: '' },
cancelCopilot: null,
// 先清空再去解析:留着上一张图的会话 id,这中间的任何一条指令
// 都会带着别的图的上下文发出去
copilotConversationId: null,
copilotMemory: { past: [], total: 0, turns: 0 },
// 撤销栈属于这张图:撤回去撤出另一张图的节点,比没有撤销更糟
past: [], future: [], pendingNote: '',
})
if (!workflow) return
void ensureCanvasConversation(workflow.id, set, get)
void get().analyzeNow()
},
setGraph: (graph) => {
if (locked(get)) return false
const { nodes, edges } = toFlow(graph)
// 整图替换(Copilot、导入)带了 defaults 才换;没带的不能当成「清空」
if (graph.defaults !== undefined) graphExtras = { ...graphExtras, ...extrasOf({ ...graph, viewport: undefined }) }
glideSeq++
commit(set, get, '替换整个画布')
set({ nodes, edges, selectedId: null, dirty: true, fitRequest: get().fitRequest + 1 })
void get().validate()
return true
},
applyFixes: (graph, label) => {
if (locked(get)) return false
const next = toFlow(graph)
// 发布前修复可能改的是全图默认(比如把 defaults.approval 从 never 改成 dangerous)。
// 后端回来的整张图总带着 defaults,照它换;viewport 留着画布自己的
if (graph.defaults !== undefined) {
const { viewport } = graphExtras
graphExtras = { ...extrasOf({ ...graph, viewport: undefined }), ...(viewport ? { viewport } : {}) }
}
const { nodes: cur, selectedId } = get()
const byId = new Map(cur.map((n) => [n.id, n]))
// 已有的节点只换类型、名字和配置:位置、量好的尺寸、选中都留着,React Flow 不用重新量一遍。
// 类型也得跟着换——一键升级会把模型调用换成报告撰写,只换配置的话卡片还是模型调用,存下去的也是
const nodes = next.nodes.map((n) => {
const old = byId.get(n.id)
return old
? { ...old, data: { ...old.data, nodeType: n.data.nodeType, label: n.data.label, config: n.data.config } }
: n
})
glideSeq++
commit(set, get, label)
set({
nodes, edges: next.edges,
selectedId: selectedId && nodes.some((n) => n.id === selectedId) ? selectedId : null,
dirty: graphSig(nodes, next.edges) !== savedSig,
})
void get().validate()
return true
},
previewUpgrade: async ({ assist = false } = {}) => {
const lock = editLockOf(get())
if (lock) {
toast.warn(EDIT_LOCK_TEXT[lock], { key: 'studio:readonly' })
return
}
upgradeCtl?.abort()
const ctl = new AbortController()
upgradeCtl = ctl
const seq = ++upgradeSeq
const { nodes, edges, workflow } = get()
const graph = toGraph(nodes, edges)
// 受管的图升级完还要按受管重新发布:新写出来的报告节点直接按受管门禁的要求配。按当前发布版的级别认(画布上改过
// 之后 status 回到草稿,受管工作流仍是受管的)
const level = workflow ? publishedLevelOf(workflow) : 'published'
set({ upgrade: { status: 'loading', assist, seq } })
try {
const raw = await api.copilot.upgradeEvidence({ graph, level, ...(assist ? { assist: true } : {}) }, { signal: ctl.signal })
if (ctl.signal.aborted || get().upgrade?.seq !== seq) return
set({ upgrade: { status: 'ready', assist, seq, result: normalizeUpgrade(raw), sig: contentSig(graph), base: graph } })
} catch (e) {
if (ctl.signal.aborted || get().upgrade?.seq !== seq || (e as { name?: string } | null)?.name === 'AbortError') return
set({ upgrade: isMissingEndpoint(e) ? { status: 'unsupported', assist, seq } : { status: 'error', assist, seq, error: e } })
}
},
applyUpgrade: async () => {
const u = get().upgrade
if (u?.status !== 'ready' || !u.result.graph || u.apply?.status === 'saving') return false
const { nodes, edges } = get()
// 预览是按发请求那一刻的画布算的:之后又改过的话,套上去会把那几下盖掉
if (contentSig(toGraph(nodes, edges)) !== u.sig) {
set({ upgrade: { ...u, apply: { status: 'stale' } } })
return false
}
if (!get().applyFixes(u.result.graph, UPGRADE_TEXT.undoLabel)) {
const lock = editLockOf(get())
set({ upgrade: { ...u, apply: { status: 'locked', why: EDIT_LOCK_TEXT[lock ?? 'formal'] } } })
return false
}
return saveUpgrade(set, get)
},
retryUpgradeSave: async () => {
const u = get().upgrade
if (u?.status !== 'ready' || !upgradeUnsaved(u.apply) || !u.result.graph) return false
// 画布上得还是升级完的样子才替它存:撤销过升级、或者之后又改过,再存下去的就不是这次升级了,
// 版本说明却还写着「升级为可追溯结构」。对不上就说这份预览过时了,要存按平常的保存来
const { nodes, edges } = get()
// 升级后的图按 applyFixes 落画布的同一套换算一遍再比(没写名字的节点会补上默认名)
const applied = toFlow(u.result.graph)
if (contentSig(toGraph(nodes, edges)) !== contentSig(toGraph(applied.nodes, applied.edges))) {
set({ upgrade: { ...u, apply: { status: 'stale' } } })
return false
}
return saveUpgrade(set, get)
},
discardUpgrade: () => {
upgradeCtl?.abort()
upgradeCtl = null
set({ upgrade: null })
},
onNodesChange: (changes) => {
if (locked(get)) {
// 锁定期间只放行量尺寸和选中:前者是 React Flow 自己的,后者不改图
changes = changes.filter((c) => c.type === 'dimensions' || c.type === 'select')
if (!changes.length) return
}
const s = get()
const removing = changes.filter((c) => c.type === 'remove').map((c) => (c as { id: string }).id)
const moving = changes.filter((c) => c.type === 'position')
if (removing.length) commit(set, get, '删除', { key: 'delete', mergeMs: 250 })
if (moving.some((c) => (c as { dragging?: boolean }).dragging) && !dragOrigin) {
dragOrigin = { nodes: s.nodes, edges: s.edges }
}
const dragEnded = moving.some((c) => (c as { dragging?: boolean }).dragging === false)
if (!dragOrigin && moving.length && !dragEnded
&& moving.every((c) => (c as { dragging?: boolean }).dragging === undefined)) {
// 键盘方向键挪节点:没有拖动的起止,连续挪算一步
commit(set, get, '移动节点', { key: 'nudge' })
}
if (changes.some((c) => c.type === 'add' || c.type === 'replace')) commit(set, get, '改动节点')
const nodes = applyNodeChanges(changes, get().nodes) as FlowNode[]
const patch: Partial<StudioState> = { nodes }
if (dragEnded && dragOrigin) {
const origin = dragOrigin
dragOrigin = null
// 只是点了一下(没真挪)不记
const moved = nodes.some((n) => {
const o = origin.nodes.find((x) => x.id === n.id)
return o && (Math.round(o.position.x) !== Math.round(n.position.x)
|| Math.round(o.position.y) !== Math.round(n.position.y))
})
if (moved) commit(set, get, '移动节点', origin)
}
// React Flow 自己的选中(点选、框选、Shift 多选)回写 selectedId:单选就打开检查器,
// 多选就收起——检查器一次只能编辑一个
if (changes.some((c) => c.type === 'select')) {
const picked = nodes.filter((n) => n.selected)
if (picked.length === 1 && s.selectedId !== picked[0].id) patch.selectedId = picked[0].id
else if (picked.length > 1 && s.selectedId) patch.selectedId = null
}
if (removing.length) {
if (s.selectedId && removing.includes(s.selectedId)) patch.selectedId = null
deletedToast(get, s.nodes.filter((n) => removing.includes(n.id)))
}
// 只有拖动结束和增删才算改动,实时拖动不标脏,否则自动保存会疯狂触发
if (dragEnded || removing.length || changes.some((c) => c.type === 'add' || c.type === 'replace')) {
patch.dirty = true
}
set(patch)
// 孤立节点被删时 React Flow 不会顺带删边,以前这时不会重新校验,工具栏的计数会滞后
if (removing.length) void get().validate()
},
onEdgesChange: (changes) => {
if (locked(get)) {
changes = changes.filter((c) => c.type === 'select')
if (!changes.length) return
}
const structural = changes.some((c) => c.type !== 'select')
if (changes.some((c) => c.type === 'remove')) commit(set, get, '删除', { key: 'delete', mergeMs: 250 })
else if (structural) commit(set, get, '改动连线')
set({ edges: applyEdgeChanges(changes, get().edges), ...(structural ? { dirty: true } : {}) })
if (structural) void get().validate()
},
onConnect: (conn) => {
if (locked(get)) return
commit(set, get, '连线')
// 查询节点连到合并查询:顺手把它加成合并的输入(别名取有意义的短名),和连线同一步撤销
const nodes = connectMergeInput(get().nodes, conn.source, conn.target)
set({
edges: addEdge({ ...conn, type: 'flow' }, get().edges),
...(nodes ? { nodes } : {}),
dirty: true,
})
void get().validate()
},
addNode: (type, position) => {
if (locked(get)) return
const def = NODE_DEFS[type]
if (!def) return
const { nodes } = get()
let at = position
if (!at) {
// 视口中心是卡片的中心,不是左上角
const c = get().getViewportCenter?.() ?? centerOf(nodes)
at = freeSpot(nodes, { x: c.x - CARD_W / 2, y: c.y - CARD_H / 2 })
}
const node: FlowNode = {
id: nextId(type),
type: 'card',
position: at,
selected: true,
data: {
nodeType: type, label: def.label,
config: adaptDefaults(structuredClone(def.defaults ?? {}), nodes),
},
}
commit(set, get, `添加「${def.label}」`)
set({
nodes: [...withSelection(nodes, new Set()), node], selectedId: node.id, dirty: true,
})
void get().validate()
},
updateNode: (id, patch) => {
if (locked(get)) return
const target = get().nodes.find((n) => n.id === id)
if (!target) return
// 连续改同一个节点的同一组字段(打字)合成一步:一个字一步的撤销没法用
const keys = [
...(patch.label !== undefined && patch.label !== target.data.label ? ['label'] : []),
...(patch.config !== undefined
? Object.keys({ ...target.data.config, ...patch.config })
// 不用 configSig:它把「没有这个键」和 {} 算成一样,这里要分得清
.filter((k) => JSON.stringify(target.data.config?.[k]) !== JSON.stringify(patch.config?.[k]))
: []),
]
// 什么都没变就什么都不做:JSON 字段里删个空格会原样再发一遍同一个对象,
// 以前照样记一步撤销、亮「未保存」,撤回去却看不出任何变化
if (!keys.length) return
commit(set, get, `编辑「${target.data.label || id}」`, {
key: `edit:${id}:${keys.sort().join(',')}`,
})
// 出口 handle 是从 config 算出来的(分支的 case key、human 的 mode),
// 改 config 就可能让已连好的边指向一个不存在的出口。React Flow 对这种边
// 只在 console 打一条 008 警告然后不渲染——它看不见、点不到、删不掉,
// 却照样被 toGraph 序列化存盘。所以这里同步把边跟过去。
const before = sourceHandles(target.data.nodeType, target.data.config ?? {})
const after = patch.config !== undefined ? sourceHandles(target.data.nodeType, patch.config) : before
let edges = get().edges
if (before.length && after !== before) {
const alive = new Set(after.map((h) => h.id))
// 改名场景(出口数量没变)按位置重映射,这样连好的线不会白连
const byPosition = new Map<string, string>()
if (before.length === after.length) {
before.forEach((h, i) => {
if (h.id !== after[i].id) byPosition.set(h.id, after[i].id)
})
}
// 分支按 case 的下标对应:同一个 case 改了标识,线跟着这个 case 走。按出口位置对不上
// 的情形:key=default 的 case 和「其他」是合并成一个出口的,改名之后出口多了一个;
// 这时 default 出口还在,线要是留在「其他」上,而那个 case 的条件又总是成立,
// 运行就会走进一个没有线的出口
const byCase = new Map<string, string>()
const was = target.data.config?.cases
const now = patch.config?.cases
if (target.data.nodeType === 'branch' && Array.isArray(was) && Array.isArray(now) && was.length === now.length) {
was.forEach((c: any, i: number) => {
const a = String(c?.key ?? '').trim()
const b = String(now[i]?.key ?? '').trim()
if (a && b && a !== b && alive.has(b)) byCase.set(a, b)
})
}
edges = edges.flatMap((e) => {
if (e.source !== id || !e.sourceHandle) return [e]
const follow = byCase.get(e.sourceHandle)
if (follow) return [{ ...e, sourceHandle: follow }]
if (alive.has(e.sourceHandle)) return [e]
const moved = byPosition.get(e.sourceHandle)
// 出口真的没了(删了一个 case、换了 human 模式)就把边一起去掉,
// 留着只会变成一条谁也看不见的脏边
return moved ? [{ ...e, sourceHandle: moved }] : []
})
}
set({
nodes: get().nodes.map((n) =>
n.id === id
? {
...n,
data: {
...n.data,
...(patch.label !== undefined ? { label: patch.label } : {}),
...(patch.config !== undefined ? { config: patch.config } : {}),
},
}
: n,
),
edges,
dirty: true,
})
void get().validate()
},
removeNode: (id) => {
if (locked(get)) return
const gone = get().nodes.find((n) => n.id === id)
if (!gone) return
commit(set, get, `删除「${gone.data.label || id}」`)
set({
nodes: get().nodes.filter((n) => n.id !== id),
edges: get().edges.filter((e) => e.source !== id && e.target !== id),
selectedId: get().selectedId === id ? null : get().selectedId,
dirty: true,
})
deletedToast(get, [gone])
void get().validate()
},
duplicateNode: (id) => {
const source = get().nodes.find((n) => n.id === id)
if (!source) return
cloneInto(set, get, { nodes: [source], edges: [] },
{ x: source.position.x + 40, y: source.position.y + 40 }, `复制「${source.data.label || id}」`)
},
duplicateSelection: () => {
const picked = selectionOf(get())
if (!picked.length) return 0
const ids = new Set(picked.map((n) => n.id))
const x = Math.min(...picked.map((n) => n.position.x)) + 40
const y = Math.min(...picked.map((n) => n.position.y)) + 40
return cloneInto(set, get, {
nodes: picked, edges: get().edges.filter((e) => ids.has(e.source) && ids.has(e.target)),
}, { x, y }, picked.length === 1 ? `复制「${picked[0].data.label}」` : `复制 ${picked.length} 个节点`)
},
copySelection: () => {
const picked = selectionOf(get())
if (!picked.length) return 0
const ids = new Set(picked.map((n) => n.id))
clipboard = {
nodes: picked.map((n) => ({ ...n, data: { ...n.data, config: structuredClone(n.data.config ?? {}) } })),
edges: get().edges.filter((e) => ids.has(e.source) && ids.has(e.target)),
}
return picked.length
},
pasteClipboard: () => {
if (!clipboard) return 0
const { nodes } = get()
const c = get().getViewportCenter?.() ?? centerOf(nodes)
const n = clipboard.nodes.length
return cloneInto(set, get, clipboard, { x: c.x - CARD_W / 2, y: c.y - CARD_H / 2 },
n === 1 ? `粘贴「${clipboard.nodes[0].data.label}」` : `粘贴 ${n} 个节点`)
},
selectAll: () => {
const { nodes } = get()
set({ nodes: withSelection(nodes, new Set(nodes.map((n) => n.id))), selectedId: null })
},
// 以 selectedId 为准,同时改写节点上的 selected:卡片的选中环看的是 React Flow 的
// selected。以前两者从不同步,检查器在编辑新节点,选中环却留在旧节点上
select: (id) => {
const { nodes, selectedId } = get()
const next = withSelection(nodes, new Set(id ? [id] : []))
if (next === nodes && selectedId === id) return
set({ selectedId: id, nodes: next })
},
save: async (note) => {
const { workflow, nodes, edges, pendingNote } = get()
if (!workflow) return
const graph = toGraph(nodes, edges)
const text = (note ?? pendingNote).trim()
const updated = await api.workflows.update(workflow.id, { graph, ...(text ? { note: text } : {}) })
savedSig = JSON.stringify(graph)
// 请求在途时又改了的话,那部分还没存:不能把「未保存」清掉
set({ workflow: updated, dirty: graphSig(get().nodes, get().edges) !== savedSig, pendingNote: '' })
// 升级落到画布上之后没存上(存失败、要存时锁着),这回平常的保存(⌘S、工具栏)存上了:画布上是什么就存了什么,
// 升级要么跟着存进去了、要么已经撤销掉了,「草稿没保存上」都不再是真的。留着的话再点「重试保存」
// 会多存一版,版本说明还写着「升级为可追溯结构」
const u = get().upgrade
if (u?.status === 'ready' && upgradeUnsaved(u.apply)) set({ upgrade: null })
},
/**
* 校验 + 变量分析。名字保留 validate,因为图一变就该重算的地方有八处,
* 都在调它。
*
* 防抖是必须的,不是优化:在此之前它是**零防抖**的——Inspector 里每敲
* 一个键都会 updateNode → validate(),实测敲 15 个字发 15 次全图 POST,
* 每次都把整张图序列化上传。再挂一个变量分析就是翻倍。
*
* 变量表另外按结构签名跳过:改 prompt 文本不会改变"有哪些变量",只有
* 增删节点、改 assign_to、改入口字段才会。签名不变就不重复请求。
*/
validate: async () => {
const { nodes, analysis } = get()
if (!nodes.length) {
set({ issues: [], advice: [], variables: [], varIssues: [], analysis: 'ok', analysisError: null })
return
}
// 已经有一份结论时不翻回「校验中」:连续打字会让工具栏的标签一直闪。
// 还没结论(刚打开)或者上次失败了,才说「校验中」
if (analysis !== 'ok' && analysis !== 'pending') set({ analysis: 'pending' })
if (analyzeTimer !== null) clearTimeout(analyzeTimer)
analyzeTimer = setTimeout(() => void runAnalysis(set, get), ANALYZE_DEBOUNCE_MS)
},
/** 不等防抖,立刻算一次。抽屉打开、切换工作流、失败后重试这类明确动作用它。 */
analyzeNow: async () => {
if (analyzeTimer !== null) clearTimeout(analyzeTimer)
analyzeTimer = null
if (get().analysis === 'failed') set({ analysis: 'pending' })
await runAnalysis(set, get, true)
},
undo: () => {
const s = get()
if (locked(get) || !s.past.length) return
const entry = s.past[s.past.length - 1]
dragOrigin = null
set({
past: s.past.slice(0, -1),
future: [...s.future, { ...entry, nodes: s.nodes, edges: s.edges, at: Date.now(), key: undefined }],
})
afterJump(set, get, entry.nodes, entry.edges)
},
redo: () => {
const s = get()
if (locked(get) || !s.future.length) return
const entry = s.future[s.future.length - 1]
dragOrigin = null
set({
future: s.future.slice(0, -1),
past: [...s.past, { ...entry, nodes: s.nodes, edges: s.edges, at: Date.now(), key: undefined }],
})
afterJump(set, get, entry.nodes, entry.edges)
},
restoreVersion: (version, graph) => {
if (locked(get)) return
const { nodes, edges } = toFlow(graph)
glideSeq++
commit(set, get, `恢复到 v${version}`)
set({
nodes, edges, selectedId: null, fitRequest: get().fitRequest + 1,
dirty: graphSig(nodes, edges) !== savedSig,
// 恢复不直接调后端的 restore:那个接口不会把受管 / 已发布退回草稿,一张受管
// 工作流恢复成未过闸的旧图后,工具栏仍会显示「受管」。走普通保存(PATCH)
// 就会按规矩退回草稿,版本说明里写清是从哪一版回来的
pendingNote: `恢复到 v${version}`,
})
void get().validate()
},
traceVariable: (path) => {
const cur = get().lineage
if (!path) {
if (cur) set({ lineage: null })
return
}
if (cur?.var === path) return
const v = get().variables.find((x) => x.path === path)
if (!v) {
if (cur) set({ lineage: null })
return
}
const producers = v.produced_by ? [v.produced_by] : []
const consumers = [...new Set(v.refs.map((r) => r.node_id))].filter((id) => !producers.includes(id))
set({ lineage: { var: path, producers, consumers } })
},
// ---- 运行 ----
startRun: async (input) => {
const { workflow, nodes, edges } = get()
get().unsubscribe?.()
// 助手的「新节点」高亮让位给运行态:紫框留着会盖住运行中、失败的边框
set({ ...runReset(), run: null, unsubscribe: null, copilotNew: [] })
try {
const run = await api.runs.start({
workflow_id: workflow?.id,
graph: toGraph(nodes, edges),
input,
origin: 'canvas',
})
const trace = seedTrace(run)
set({ run, streaming: true, trace, runPhase: trace.phase, runSnapshot: snapshotOf(nodes, edges) })
await get().attachRun(run.id)
return run
} catch (e) {
set({ streaming: false })
throw e
}
},
runCopilot: (instruction, useBase, model) => {
// 正式运行跑的是已发布的版本,画布此刻只读:助手改完的图落不下来,不如先说清楚
if (formalRunning(get())) {
toast.warn(EDIT_LOCK_TEXT.formal, { key: 'studio:readonly' })
return false
}
// 上一轮还在跑:先按停止收掉,免得两条流一起往画布上写
if (get().copilot.active) get().stopCopilot()
glideSeq++
const state = get()
const turnId = `c${Date.now().toString(36)}${(idSeq++ % 1000).toString(36)}`
const before = { nodes: state.nodes, edges: state.edges }
// 整轮算一步:这一轮开始之前的画布就是撤销点。以前「重新生成」一提交就清空画布,
// 生成到一半停下、改坏了,都只能靠不保存再刷新来挽回
const checkpoint = commit(set, get, `助手:${instruction.length > 24 ? instruction.slice(0, 24) + '…' : instruction}`)!
/** 这一轮是不是已经收尾了(final / reply / error / 停止 / 断流,先到先算) */
let finished = false
/** 从头生成:收到第一个节点再清空画布。只回一句话、一开始就失败时,画布不该被清掉 */
let cleared = useBase
/** 已经挨着上游摆好的新节点。没等到入边就先落了位的,入边到了再挪过去 */
const anchored = new Set<string>()
/** 前端认不出来、没放上画布的节点类型。后端 final.issues 没说到的,收尾时补上,不能安静地少一步 */
const dropped: string[] = []
/** 自查时报出来的工具被删(check.warnings)。收尾时和 final 里同样的那几条合并去重 */
const toolDrops: CopilotIssue[] = []
const withDropped = (raw: unknown): CopilotIssue[] => {
const issues: CopilotIssue[] = Array.isArray(raw) ? [...raw] : []
for (const type of dropped) {
if (issues.some((i) => i.code === 'unknown_node_type' && i.type === type)) continue
issues.push({ level: 'warning', node_id: null, code: 'unknown_node_type', type,
message: `模型生成了不存在的节点类型「${type}」,已跳过该步骤` })
}
return issues
}
set({
copilot: {
active: true, lastOp: '', explanation: '', error: '', errorHint: '', errorDetail: '', model: model ?? '',
phase: 'connecting', thinking: '', elapsedMs: 0,
lastInstruction: instruction, lastUseBase: useBase,
},
copilotNew: [],
copilotCursor: null,
// 检查器让开:画布锁着,开着也改不了
selectedId: null,
nodes: withSelection(state.nodes, new Set()),
copilotTurns: [
...state.copilotTurns.slice(-(COPILOT_TURN_LIMIT - 1)),
{ id: turnId, instruction, ops: [], phase: 'running', explanation: '', error: '',
useBase, checkpoint: checkpoint.id, startedAt: Date.now() },
],
})
/**
* 记下这一条操作,供侧栏回看。
*
* thinking 在写入时就合并:一次生成的 delta 是几百上千条,逐条存下来
* 光是数组本身就比图大一个量级,而 decodeCopilot 反正也要把它们并成一条。
*/
const record = (op: CopilotOp) => {
set((s: StudioState) => ({
copilotTurns: s.copilotTurns.map((t) => {
if (t.id !== turnId) return t
const last = t.ops[t.ops.length - 1]
if (op.op === 'thinking' && last?.op === 'thinking') {
const merged = { ...last, delta: String(last.delta ?? '') + String(op.delta ?? '') }
return { ...t, ops: [...t.ops.slice(0, -1), merged] }
}
return { ...t, ops: [...t.ops, op] }
}),
}))
}
/** 这一轮查看过什么,随轮次存进 meta.looks(look §2.5.8);没查看过就不写 meta */
const looksMeta = (): { meta?: { looks: LookEvent[] } } => {
const looks = looksOf(get().copilotTurns.find((t) => t.id === turnId)?.ops ?? [])
return looks.length ? { meta: { looks } } : {}
}
/** 助手这一轮问回来的那句话(ask):落库时作为这一轮的回答进历史,下一轮模型知道自己问过什么(N11) */
const askedText = (): string => {
const ops = get().copilotTurns.find((t) => t.id === turnId)?.ops ?? []
const ask = [...ops].reverse().find((o) => o.op === 'ask')
return ask ? String(ask.question ?? '').trim() : ''
}
const settle = (patch: Partial<CopilotTurn>) => {
set((s: StudioState) => ({
copilotTurns: s.copilotTurns.map((t) => (t.id === turnId ? { ...t, ...patch } : t)),
}))
}
const finish = (patch: Partial<StudioState['copilot']> = {}) => {
if (activeTurn?.id === turnId) activeTurn = null
set({
copilot: { ...get().copilot, active: false, lastOp: '', phase: '', thinking: '',
elapsedMs: 0, errorHint: '', errorDetail: '', ...patch },
cancelCopilot: null, copilotCursor: null,
})
}
/**
* 这一轮没走完(停止、失败、断流):画布退回这一轮之前。
*
* 半成品不扔:放进 future,⇧⌘Z 能找回来。以前停下来会把半张图留在画布上,
* 「重新生成」模式下更糟——原来那张图已经被清空了。
*/
const revert = (): 'reverted' | 'unchanged' => {
const s = get()
const past = s.past[s.past.length - 1]?.id === checkpoint.id ? s.past.slice(0, -1) : s.past
if (!diffGraphs(before, s).total) {
set({ past, copilotNew: [] })
return 'unchanged'
}
set({
past, copilotNew: [],
future: [...s.future, {
id: ++historySeq, label: '助手未完成的修改', nodes: s.nodes, edges: s.edges, at: Date.now(),
}],
})
afterJump(set, get, before.nodes, before.edges)
return 'reverted'
}
// 流式期间的临时摆位:挨着上游放,没有上游就放在视口中心附近的空地上。
// 以前没有上游的节点排在 x=120+n*290,常常落在视口外面,看不见它在长
const place = (nodeId: string): { x: number; y: number } => {
const { nodes, edges } = get()
const others = nodes.filter((n) => n.id !== nodeId)
const incoming = edges.find((e) => e.target === nodeId && others.some((n) => n.id === e.source))
const source = incoming && others.find((n) => n.id === incoming.source)
if (source) {
anchored.add(nodeId)
return freeSpot(others, { x: source.position.x + (source.measured?.width ?? CARD_W) + 52, y: source.position.y })
}
const c = get().getViewportCenter?.() ?? centerOf(others)
return freeSpot(others, { x: c.x - CARD_W / 2, y: c.y - CARD_H / 2 })
}
const stop = streamCopilot(
{
instruction,
base_graph: useBase && state.nodes.length ? toGraph(state.nodes, state.edges) : null,
model: model ?? undefined,
conversation_id: state.copilotConversationId,
},
(op) => {
if (finished) return
const s = get()
if (op.op === 'final') {
// 卡片上的「少了一步」、回执里的工具绑定变化读的都是记下来的 final:这里认不出来
// 而后端没提的类型,老后端不给的 tool_changes(前端自己比对),一并补齐了再记
op = {
...op,
issues: withDropped(op.issues),
tool_changes: Array.isArray(op.tool_changes) ? op.tool_changes
: toolChangesOf(before.nodes, op.graph ? toFlow(op.graph).nodes : []),
}
}
record(op)
switch (op.op) {
case 'model':
// 后端首帧告知实际用的模型,浮条上直接显示,不用猜
set({ copilot: { ...s.copilot, model: op.model ?? '' } })
break
case 'thinking':
// 模型正在想什么,原样接上去。看着它想比盯着"正在起草…"强得多
set({
copilot: {
...s.copilot,
phase: s.copilot.phase === 'connecting' ? 'planning' : s.copilot.phase,
thinking: (s.copilot.thinking + (op.delta ?? '')).slice(-4000),
},
})
break
case 'heartbeat':
// 模型沉默期间的补拍,用来刷新阶段和已用时长。查看进行中(looking)浮条直说「正在查看表结构…」,
// 不留着上一条操作的说法——那会像是卡在了上一步
set({
copilot: {
...s.copilot,
phase: (op.phase as any) ?? s.copilot.phase,
elapsedMs: op.elapsed_ms ?? s.copilot.elapsedMs,
...(op.phase === 'looking' ? { lastOp: LOOK_TEXT.running } : {}),
},
})
break
case 'look':
case 'context': {
// 助手查看了表结构(老服务端是预先挑表的 context):浮条上说查看了什么,展开的过程里有表名(decodeCopilot)。
// 查看记录随这一轮存进 meta.looks(recordCanvasTurn)
const look = op.op === 'look' ? copilotLook(op) : copilotContext(op)
if (look) set({ copilot: { ...s.copilot, lastOp: look.title } })
break
}
case 'catalog_patch': {
// 助手把用户说的数据事实整理成了目录修改提案:浮条上先说一句,卡片在这一轮的对话里(catalogPatchesOf),
// 人点「保存到数据目录」才写入。和画布无关,不动节点、不占撤销栈
const patch = catalogPatchOf(op)
if (patch) set({ copilot: { ...s.copilot, lastOp: CATALOG_PATCH_TEXT.step(patch.tableLabel ?? patch.table, patch.changes.length) } })
break
}
case 'plan':
set({ copilot: { ...s.copilot, phase: 'planning', lastOp: op.summary ?? '规划中' } })
break
case 'check': {
// 服务端自查:用运行时同一套规则过一遍,有问题交回模型改
// 以前是一句话,后端改成 {node_id, message, field?} 之后能定位到节点,两种都接住。
// 带节点的前面补上节点名,「再修一次」拼指令时模型才知道说的是哪个
const c = op as CopilotCheckOp
const items = (Array.isArray(c.issues) ? c.issues : []).map(checkIssueOf)
const lineOf = (x: CopilotIssue): string => {
const label = x.node_id ? s.nodes.find((n) => n.id === x.node_id)?.data.label : ''
return label && !x.message.includes(`「${label}」`) ? `「${label}」:${x.message}` : x.message
}
const issues = items.map(lineOf)
// 工具被删不挡运行,但自查这一步就要说出来(tools_dropped)
const warnings: CopilotCheckIssue[] = Array.isArray(c.warnings) ? c.warnings : []
for (const w of warnings) if (w && typeof w === 'object') toolDrops.push(checkIssueOf(w))
settle({ check: { status: c.status, issues, items, round: c.round, repaired: c.repaired,
message: c.message,
...(warnings.length ? { warnings: warnings.map((w) => lineOf(checkIssueOf(w))) } : {}) } })
set({ copilot: { ...s.copilot,
phase: c.status === 'repairing' ? 'repairing' : s.copilot.phase,
lastOp: c.status === 'repairing'
? `第 ${c.round ?? 1} 轮修正:自查发现 ${issues.length} 处问题`
: c.status === 'passed'
? (c.repaired ? `自查发现的问题已修复(${c.repaired} 轮)` : '自查通过')
: c.status === 'failed' ? `自查后仍有 ${issues.length} 处问题` : '自查修正未完成' } })
break
}
case 'reply': {
// 这一句不需要改图。画布上什么都没发生,不能说「流程已更新到画布」
finished = true
revert()
const text = String(op.text ?? '')
settle({ phase: 'done', outcome: 'answered', reply: text })
finish({ explanation: '', error: '' })
recordCanvasTurn(get().copilotConversationId, instruction, { answer: text, status: 'done', ...looksMeta() }, set)
break
}
case 'add_node': {
const n = op.node
// 类型不认识就不放上画布:节点卡片、属性面板都按类型查定义,查不到
// 以前是整站白屏、连带没保存的编辑一起丢。后端也会拦,这里是第二道
if (!n?.id || !n?.type) break
if (!NODE_DEFS[n.type as NodeType]) {
if (!dropped.includes(String(n.type))) dropped.push(String(n.type))
break
}
if (!cleared) {
cleared = true
set({ nodes: [], edges: [] })
}
const cur = get()
const node: FlowNode = {
id: n.id, type: 'card', position: { x: 0, y: 0 },
data: { nodeType: n.type, label: n.label ?? '', config: n.config ?? {} },
}
set({
nodes: [...cur.nodes.filter((x) => x.id !== n.id), node],
copilotNew: cur.copilotNew.includes(n.id) ? cur.copilotNew : [...cur.copilotNew, n.id],
copilotCursor: n.id,
copilot: { ...cur.copilot, phase: cur.copilot.phase === 'repairing' ? 'repairing' : 'building',
lastOp: `添加节点:${n.label || n.id}` },
dirty: true,
})
// 位置要等边可能已到齐后算——直接再取一次最新状态摆位
set({
nodes: get().nodes.map((x) => (x.id === n.id ? { ...x, position: place(n.id) } : x)),
})
break
}
case 'update_node': {
const target = s.nodes.find((x) => x.id === op.id)
if (!target) break
// 按字段合并,和后端 merge_node_config 同一套规则:没写的保留、写 null 删键、
// 协作成员按 name 合并。整体替换的话,模型只改一句提示词,工具就跟着没了——
// 流到一半断掉时,重做栈里的半成品就是那个没有工具的样子
const patch = op.config && typeof op.config === 'object' && !Array.isArray(op.config) ? op.config : null
set({
nodes: s.nodes.map((x) =>
x.id === op.id
? { ...x, data: { ...x.data,
...(op.label != null ? { label: op.label } : {}),
...(patch ? { config: mergeNodeConfig(x.data.nodeType, x.data.config ?? {}, patch) } : {}) } }
: x),
copilotNew: s.copilotNew.includes(op.id) ? s.copilotNew : [...s.copilotNew, op.id],
copilotCursor: op.id,
copilot: { ...s.copilot, lastOp: `修改节点:${op.label || target.data.label || op.id}` },
dirty: true,
})
break
}
case 'remove_node':
set({
nodes: s.nodes.filter((x) => x.id !== op.id),
edges: s.edges.filter((e) => e.source !== op.id && e.target !== op.id),
copilotNew: s.copilotNew.filter((id) => id !== op.id),
copilot: { ...s.copilot, lastOp: `移除节点:${op.id}` },
dirty: true,
})
break
case 'add_edge': {
const e = op.edge
if (!e?.source || !e?.target) break
set({
edges: [...s.edges, {
id: `cp_${e.source}_${e.sourceHandle ?? ''}_${e.target}`,
source: e.source, target: e.target,
sourceHandle: e.sourceHandle ?? null, type: 'flow',
}],
copilot: { ...s.copilot, phase: s.copilot.phase === 'repairing' ? 'repairing' : 'wiring',
lastOp: `连线:${e.source} → ${e.target}` },
dirty: true,
})
// 这一轮新加的节点先于它的入边落了位:入边到了,挪到上游旁边去
if (s.copilotNew.includes(e.target) && !anchored.has(e.target)
&& !before.nodes.some((n) => n.id === e.target)) {
set({ nodes: get().nodes.map((x) => (x.id === e.target ? { ...x, position: place(e.target) } : x)) })
}
break
}
case 'remove_edge':
set({
edges: s.edges.filter((e) =>
!(e.source === op.source && e.target === op.target
&& (op.sourceHandle == null || e.sourceHandle === op.sourceHandle))),
dirty: true,
})
break
case 'done':
set({ copilot: { ...s.copilot, phase: 'finalizing', lastOp: '排版整理中…',
explanation: op.explanation ?? '' } })
break
case 'final': {
finished = true
const next = toFlow(op.graph)
// 改图时后端只给新节点排版,旧节点留在用户摆好的位置(layout.mode='keep')。
// 老后端不带 layout、整张图重排过:旧节点照样沿用这一轮之前的坐标,不瞬移
const keep = useBase && (op.layout?.mode === 'keep' || !op.layout)
const old = new Map(before.nodes.map((n) => [n.id, n]))
const live = new Map(get().nodes.map((n) => [n.id, n]))
const nodes: FlowNode[] = next.nodes.map((n) => {
const prev = old.get(n.id)
// 量过的尺寸带过去:不然走线先按默认尺寸画一遍,量完再跳一下
const measured = live.get(n.id)?.measured ?? prev?.measured
return {
...n,
...(keep && prev ? { position: prev.position } : {}),
...(measured ? { measured } : {}),
}
})
const diff = diffGraphs(before, { nodes, edges: next.edges })
// 上面记录时已经补齐:认不出的类型并进了 issues,老后端缺的 tool_changes 由前端比对
const issues: CopilotIssue[] = op.issues
const toolChanges: ToolChange[] = op.tool_changes
const toolWarnings = dedupeIssues([...toolDrops, ...issues.filter((i) => i.code === 'tools_dropped')])
const explanation = op.explanation ?? get().copilot.explanation
const outcome = diff.total ? 'applied' : 'unchanged'
if (!diff.total) {
// 一处都没变:这一轮不占撤销栈
const p = get().past
if (p[p.length - 1]?.id === checkpoint.id) set({ past: p.slice(0, -1) })
}
const fresh = [...diff.added, ...diff.changed]
// 整张图重排过(新建、从头生成)或者多了节点:视角要跟过去,否则
// "生成好了"这句话落在一片空白上。只改了配置就别动镜头
const refit = !keep || diff.added.length > 0
// 流式期间已经摆在临时位置上的节点,从那儿滑到排版位置,而不是瞬移。
// reduced-motion 和大图直接落位
const targets = new Map(nodes.map((n) => [n.id, n.position]))
const glides = !reducedMotion() && nodes.length <= GLIDE_MAX_NODES
const shown = glides
? nodes.map((n) => {
const cur = live.get(n.id)?.position
return cur && (cur.x !== n.position.x || cur.y !== n.position.y) ? { ...n, position: cur } : n
})
: nodes
const moving = shown.some((n, i) => n !== nodes[i])
set({
nodes: shown, edges: next.edges,
dirty: graphSig(nodes, next.edges) !== savedSig,
copilotNew: fresh,
...(refit && !moving ? { fitRequest: get().fitRequest + 1 } : {}),
})
// 落定之后再取景:取景时节点还在半路的话,镜头对着的是它们出发的地方
if (moving) glide(set, get, targets, () => { if (refit) set({ fitRequest: get().fitRequest + 1 }) })
settle({ phase: 'done', outcome, diff, issues, explanation, toolChanges, toolWarnings })
finish({ explanation, error: '' })
recordCanvasTurn(get().copilotConversationId, instruction, {
graph: op.graph, explanation: explanation ?? '', status: 'done', ...looksMeta(),
...(askedText() ? { answer: askedText() } : {}),
}, set)
void get().validate()
setTimeout(() => {
// 这 6 秒里又开了一轮的话,高亮归新的那一轮管
if (get().copilotNew === fresh) set({ copilotNew: [] })
}, 6000)
if (outcome === 'applied') {
const turn = get().copilotTurns.find((t) => t.id === turnId)
const receipt = copilotReceipt({
total: diff.total,
left: turn?.check?.status === 'failed' ? turn.check.issues.length : 0,
missing: issues.filter((i) => i.code === 'unknown_node_type').length,
toolChanges, toolWarnings,
})
toast(receipt.text, receipt.kind, {
key: `copilot:${turnId}`, duration: 8000, sticky: receipt.sticky, detail: receipt.detail,
action: { label: '撤销', onClick: () => { get().undoCopilotTurn(turnId) } },
})
}
break
}
case 'error': {
finished = true
// 保留 lastInstruction:失败后的"重试"要用它,不能让用户重填
const message = op.message ?? '生成失败'
const outcome = revert()
settle({ phase: 'error', error: message, outcome })
// 「怎么办」和原始报错一起留下:Composer 的错误条和问数据页一样摊开它们
finish({ explanation: '', error: message,
errorHint: typeof op.hint === 'string' ? op.hint : '',
errorDetail: typeof op.detail === 'string' ? op.detail : '' })
recordCanvasTurn(get().copilotConversationId, instruction, { status: 'error', error: message, ...looksMeta() }, set)
break
}
}
},
(error) => {
if (finished) {
if (activeTurn?.id === turnId) activeTurn = null
if (get().cancelCopilot === stop) set({ cancelCopilot: null })
return
}
finished = true
// 只问不改的一轮(ask 之后流就结束了,N11):画布没动,问题当成这一轮的回话摆出来,照样记进会话、进历史——
// 以前这一轮被当成「没修改画布」收掉,也不落库,下一轮模型不知道自己问过什么
const asked = error ? '' : askedText()
if (asked) {
revert()
settle({ phase: 'done', outcome: 'answered', reply: asked })
finish({ explanation: '', error: '' })
recordCanvasTurn(get().copilotConversationId, instruction, { answer: asked, status: 'done', ...looksMeta() }, set)
return
}
// 流断了但没收到 final / error / reply:这一轮不能一直挂在"进行中",
// 否则侧栏会永远转圈,而后台其实什么都不会再来了。改了一半的画布退回去
const outcome = revert()
const message = error ?? (outcome === 'reverted' ? '本轮连接中断,画布已恢复到本轮之前的状态' : '')
settle(message ? { phase: 'error', error: message, outcome } : { phase: 'done', outcome })
finish({ error: message })
},
)
activeTurn = {
id: turnId,
stop: () => {
if (finished) return
finished = true
stop()
const outcome = revert()
settle({ phase: 'error', error: '已停止', outcome })
finish({})
},
abandon: () => {
finished = true
stop()
},
}
set({ cancelCopilot: stop })
return true
},
stopCopilot: () => {
if (activeTurn) {
activeTurn.stop()
return
}
get().cancelCopilot?.()
set({
copilot: { ...get().copilot, active: false, phase: '', thinking: '' },
cancelCopilot: null, copilotNew: [], copilotCursor: null,
copilotTurns: get().copilotTurns.map((t) =>
t.phase === 'running' ? { ...t, phase: 'error', error: '已停止' } : t),
})
},
clearCopilot: () => { void get().newCopilotConversation() },
newCopilotConversation: async () => {
const workflow = get().workflow
if (get().copilot.active) get().stopCopilot()
// 先把界面清了:就算新会话建不成,也不能让旧轮次挂在那儿冒充「这次对话」。上一段的
// 报错一起清——空面板上输入框会摊开错误条,旧的那条会被当成这一段出的错
set({
copilotTurns: [], copilotMemory: { past: [], total: 0, turns: 0 },
copilot: { ...get().copilot, error: '', errorHint: '', errorDetail: '' },
})
if (!workflow) {
set({ copilotConversationId: null })
return
}
try {
const created = await api.conversations.create({ kind: 'canvas', workflow_id: workflow.id })
if (get().workflow?.id !== workflow.id) return
set({ copilotConversationId: created.id })
} catch (e) {
// 建不成就不带会话:下一条指令没有历史,而不是悄悄带着旧的
set({ copilotConversationId: null })
toast.error(e, { detail: '新对话创建失败,下一条指令将不带历史记录发送' })
}
},
repairWithCopilot: (turnId) => {
const s = get()
const turn = turnId ? s.copilotTurns.find((t) => t.id === turnId) : s.copilotTurns[s.copilotTurns.length - 1]
const lines: string[] = []
if (turn?.check && turn.check.status !== 'passed') lines.push(...turn.check.issues)
for (const i of turn?.issues ?? []) {
if (i.code === 'unknown_node_type') {
lines.push(`上一轮缺少一步:使用了不存在的节点类型「${i.type ?? '?'}」,请换用现有的节点类型补上这一步`)
} else if (i.level === 'error') {
lines.push(i.message)
}
}
if (!lines.length) {
// 这一轮没留下问题清单:拿画布眼下的校验错误来修
const label = (id?: string | null) => s.nodes.find((n) => n.id === id)?.data.label || id
for (const i of s.issues) {
if (i.level === 'error') lines.push(i.node_id ? `「${label(i.node_id)}」:${i.message}` : i.message)
}
}
if (!lines.length) {
toast.info('没有需要修复的问题')
return
}
const unique = [...new Set(lines)]
const instruction = '修正此工作流中的下列问题,只修改有问题的地方,其他节点保持不变:\n'
+ unique.map((l, i) => `${i + 1}. ${l}`).join('\n')
get().runCopilot(instruction, true, s.copilot.model || null)
},
undoCopilotTurn: (turnId) => {
const s = get()
const turn = s.copilotTurns.find((t) => t.id === turnId)
const top = s.past[s.past.length - 1]
// 正式运行期间 undo 会被锁拦下、画布不动:不能照样把这一轮标成「已撤回」
if (formalRunning(s)) {
toast.warn(EDIT_LOCK_TEXT.formal, { key: 'studio:readonly' })
return false
}
if (!turn?.checkpoint || !top || top.id !== turn.checkpoint || s.copilot.active) {
toast.warn(`本轮之后画布已有其他修改,无法单独撤销本轮。请使用 ${formatShortcut('Mod+Z')} 逐步撤销,或从版本历史中恢复`)
return false
}
get().undo()
set((st: StudioState) => ({
copilotTurns: st.copilotTurns.map((t) => (t.id === turnId ? { ...t, outcome: 'reverted' } : t)),
}))
return true
},
retryCopilot: () => {
// 失败后用同一条需求重来。以前只能重新打开 Modal 把需求再敲一遍,
// 而失败往往跟需求本身无关(模型抽风、协议跑偏、网络断了)
const { lastInstruction, lastUseBase, model } = get().copilot
if (!lastInstruction) return
get().runCopilot(lastInstruction, lastUseBase, model || null)
},
startFormalRun: async (input) => {
const { workflow, nodes, edges } = get()
if (!workflow) return null
get().unsubscribe?.()
set({ ...runReset(), run: null, unsubscribe: null, copilotNew: [] })
try {
// 正式运行不传 graph:后端只认已发布的不可变版本
const run = await api.runs.start({
workflow_id: workflow.id,
run_class: 'formal',
input,
origin: 'launcher',
})
const trace = seedTrace(run)
// 正式运行跑的是已发布版本;画布有未保存改动时不让发起,所以此刻的画布就是它
set({ run, streaming: true, trace, runPhase: trace.phase, runSnapshot: snapshotOf(nodes, edges) })
await get().attachRun(run.id)
return run
} catch (e) {
set({ streaming: false })
throw e
}
},
attachRun: async (runId) => {
get().unsubscribe?.()
streamEpoch += 1
// 手上已有的事件不要再收一遍。审批恢复会走到这里,而 applyEvent 是无条件
// 追加——不传 after 的话后端把整条历史重推一遍,时间线上每条都出现两次。
const current = get()
const same = current.run?.id === runId
if (!same) {
// 换了一条运行(从运行页跳进画布看历史):上一条的状态一样都不能留,
// 不然两条运行的节点状态会叠在一张图上
set({ ...runReset(), run: null, streaming: false, unsubscribe: null })
const run = await api.runs.get(runId).catch(() => null)
if (get().run) return // 等的这会儿用户又发起了别的运行
if (run) {
const trace = seedTrace(run)
set({ run, trace, runPhase: trace.phase })
}
}
const after = same
? current.events.reduce((max, e) => Math.max(max, e.seq ?? 0), 0)
: 0
const stop: () => void = streamRun(
runId,
(event) => get().applyEvent(event),
(end) => {
if (get().unsubscribe === stop) set({ unsubscribe: null })
set({ streaming: false })
// 结束标记带着当时的状态,先按它收尾(interrupted 而事件里没在等人的就是
// 挂起),不用等下面那次请求回来。再对一次账:有没有待审批、完整的成果
// 和用量,结束标记里都没有
const s = get()
if (end?.status && s.run?.id === runId) {
set(advance(s, { ...s.runtime }, {
seq: 0, type: 'stream.end', node_id: null, ts: s.trace.book.clock / 1000,
data: { status: end.status },
}))
}
void reconcile(runId, set, get)
},
after,
)
set({ unsubscribe: stop, streaming: true })
},
continueRun: async () => {
// 从失败的那个节点接着跑,前面跑过的不重来。
//
// 把画布**当前**这张图带过去,而不是运行时那份快照——失败的多半是配置错了
// (模型 id 写错、循环条件语法错、缺必填输入),用户正是在画布上改完它才
// 点的这里。带的是运行时那份的话,改完还会再撞同一个错。
//
// 后端只接受骨架一致的图:增删节点或改连线就拒绝。checkpoint 是按节点名
// 存的,结构变了续下去会拿着错位的状态跑出一份似是而非的结果。
const { run, nodes, edges } = get()
if (!run) return
const continued = await api.runs.continue(run.id, toGraph(nodes, edges))
set({ run: continued, streaming: true, runSnapshot: snapshotOf(nodes, edges) })
await get().attachRun(run.id)
},
stopRun: async () => {
const run = get().run
if (!run) return
try {
await api.runs.cancel(run.id)
} catch (e) {
// 409 多半说明它其实已经不在跑了(停在审批上、服务重启过)。以前这里把
// 错误吞掉再把 streaming 置假,按钮翻回"运行",审批却还挂着——对一次账
// 让界面说实话,错误交给调用方提示
void reconcile(run.id, set, get)
throw e
}
// 取消成功时 run.cancelled 会从事件流过来;流要是断了,兜底对一次账
setTimeout(() => {
if (get().run?.id === run.id && isActivePhase(get().runPhase)) void reconcile(run.id, set, get)
}, 3000)
},
clearRun: () => {
get().unsubscribe?.()
set({ ...runReset(), run: null, streaming: false, unsubscribe: null })
},
reconcileRun: async () => {
const run = get().run
if (run) await reconcile(run.id, set, get)
},
setHoveredNode: (id) => {
if (get().hoveredNodeId !== id) set({ hoveredNodeId: id })
},
focusNode: (id) => set({ focusRequest: { id, seq: (get().focusRequest?.seq ?? 0) + 1 } }),
setReplayAt: (at) => set({ replayAt: at }),
setFollow: (follow) => set({ follow }),
setLineage: (lineage) => set({ lineage }),
/**
* 把一条事件折算成画布上的可见变化。
* 这是"实时可视化"的全部秘密:事件流 → 航迹 → 节点状态 → 高亮/动效。
*
* 状态(在跑、等人、完成、失败、取消、挂起)只从航迹来;这里另外维护卡片要
* 显示的正文、思考、工具调用、协作矩阵这些内容。
*/
applyEvent: (event) => {
const state = get()
const type = String(event.type)
const nodeId = event.node_id
// 流式增量:只长正文和思考,不进 events、不碰航迹。一次运行有几千条,
// 每条都复制整个事件数组、重算一遍航迹,量级是 O(n²),而它们本来就不落库
if (type === 'llm.token' || type === 'llm.thinking.delta') {
if (!nodeId) return
const r = state.runtime[nodeId] ?? EMPTY_RUNTIME
const delta = String(event.data?.delta ?? '')
set({
runtime: {
...state.runtime,
[nodeId]: type === 'llm.token'
? { ...r, tokens: (r.tokens ?? '') + delta }
: { ...r, thinking: (r.thinking ?? '') + delta },
},
})
return
}
// 重连补发、审批恢复重接时收过的那几条
if ((event.seq ?? 0) > 0 && event.seq <= state.trace.lastSeq) return
const runtime = { ...state.runtime }
const patch = (changes: Partial<NodeRuntime>) => {
if (!nodeId) return
runtime[nodeId] = { ...(runtime[nodeId] ?? EMPTY_RUNTIME), ...changes }
}
switch (type) {
case 'node.started':
// 新一轮开始:上一轮的耗时、正文不能挂着,否则跑第 3 轮的卡片上还是第 2 轮的"2.1s"
patch({ tokens: '', thinking: '', error: undefined, toolCalls: [], durationMs: undefined })
break
case 'node.finished':
patch({ durationMs: event.data.duration_ms, preview: event.data.preview })
break
case 'node.failed':
patch({ error: event.data.error, durationMs: event.data.duration_ms })
break
case 'llm.thinking':
// 汇总事件:直接覆盖为完整思考。回放(刷新页面)时靠这一条恢复。
patch({ thinking: event.data.text ?? runtime[nodeId!]?.thinking })
break
case 'tool.start':
patch({
toolCalls: [...(runtime[nodeId!]?.toolCalls ?? []),
{ tool: event.data.tool, args: event.data.args, agent: event.data.agent }],
})
break
case 'tool.end':
case 'tool.error': {
const calls = [...(runtime[nodeId!]?.toolCalls ?? [])]
// 多 agent 时同一个工具名可能被两个成员同时调,只按名字找会配错人
const idx = calls
.map((c, i) => (c.tool === event.data.tool
&& (event.data.agent == null || c.agent === event.data.agent) ? i : -1))
.filter((i) => i >= 0)
.pop() ?? -1
if (idx >= 0) {
calls[idx] = { ...calls[idx], result: event.data.preview, ok: event.type === 'tool.end' }
}
patch({ toolCalls: calls })
break
}
case 'edge.taken':
patch({
takenHandle: String(event.data.branch ?? ''),
reason: event.data.reason ? String(event.data.reason) : undefined,
})
break
}
// 协作矩阵:只走 decode.ts 那一份翻译,免得画布和右栏对同一次运行给出不同的说法
const team = reduceTeam(runtime[nodeId ?? '']?.team, event)
if (team && nodeId) patch({ team })
set({ events: [...state.events, event], runtime, ...advance(state, runtime, event) })
},
}))
// 开发期把 store 挂到 window 上,好让 playwright 直接读状态做断言——
// 界面上看不出"事件收全了没有",只能问 store。生产构建里去掉。
if (import.meta.env.DEV) {
;(window as any).__studio = useStudio
}