import { useEffect, useId, useMemo, useState } from 'react' import type { CSSProperties } from 'react' import { AlertTriangle, Ban, Check, ChevronRight } from 'lucide-react' import clsx from 'clsx' import { api } from '../api/client' import { useCatalog } from '../store/catalog' import { asDoc } from '../store/evidence' import { useStudio } from '../store/studio' import { Spinner, useToast } from '../components/ui' import { segmentState } from '../lib/evidence' import { NONE } from '../lib/format' import { CATALOG_TABLE_FIELD_LABEL, DUAL_CHECK_TEXT } from '../lib/terms' import { patchValueText } from './catalogPatch' import { RationaleDoc } from './ChallengeSummary' import type { Approval, DualCheckBlindInput, DualCheckCard, DualCheckChoice, DualCheckInput, DualCheckMetric, DualCheckReply, DualCheckSummaryItem, EvidenceDocData, } from '../types' const T = DUAL_CHECK_TEXT.approval const CHOICES: DualCheckChoice[] = ['a', 'b', 'neither'] /** 不算具体差异的两种:兜底说明(other)和解析失败(parse)。服务端摘要的 fallback 也是这么算的 */ const NOT_CONCRETE = new Set(['other', 'parse']) /** 能对上数据目录里一项事实的三种差异:时间列 → 业务日期,筛选条件 → 有效记录条件,聚合 → 去重规则 */ type CatalogAspect = 'time' | 'filter' | 'aggregate' const CATALOG_ASPECTS = new Set(['time', 'filter', 'aggregate']) export interface DualCheckApprovalProps { /** payload.kind 为 'dual_check' 的审批:双盲复算两路对不上、交给人裁决 */ approval: Approval /** * 提交之后谁来重新接上运行的事件流,同 ApprovalCard 的 onResolved:对话页、运行页各自接,没给就走画布的 attachRun。 * 两处都接会开两条订阅,各收一份事件 */ onResolved?: (runId: string) => void | Promise } /** 一个不一致的指标在卡上要画的东西:先由 payload.summary 填,完整对照(card_artifact)到了再补全 */ interface MetricView { id: string name: string original: string | null blind: string | null /** 已乘过 100;null 是原流程值为 0(约定),undefined 是没给 */ deltaPct: number | null | undefined /** 具体差异,一条一句(兜底说明、解析失败不算) */ items: string[] /** 一条具体差异都没有:卡上不列条目,默认展开对照,审核人只能对照原文判断 */ fallbackOnly: boolean /** fallbackOnly 时写不写那句固定的「两条 SQL 的写法不同,未能归纳成具体差异」(一边没有 SQL 时不写,只写原因) */ fallbackHead: boolean /** 兜底、解析失败的原话里固定那句以外的说法(比较超时、解析出错的位置……),附在下面 */ notes: string[] /** 具体差异之外还有未能归纳的部分(服务端那句「另有未能归纳的差异」) */ rest: string | null /** 两条 SQL 等价,差在取用的结果上 */ equivalent: boolean /** 服务端没有预告时用:两边只差一处、又可能对得上数据目录的一项事实,审核人的选择可能被记进数据目录(见 catalogOf) */ catalog: CatalogAspect | null /** 服务端预告的采用哪一边会往数据目录里写什么(见 previewOf);有它就照它说,不再按 catalog 有条件地说 */ preview: CatalogPreview | null full: DualCheckMetric | null } /** 盲算一边的输入,约定之外服务端另带核查 agent 组装的理由文档(期 4;老工件没有) */ type BlindInput = DualCheckBlindInput & { rationale_doc?: unknown } /** 完整对照,约定之外服务端另带几个指标落到同一项上时每种选择组合的预告(期 4;老工件没有) */ type Card = DualCheckCard & { catalog_joint?: unknown } /** * 写到数据目录的哪一项:数据源、表、目录项(business_date / valid_filter / dedup)。服务端写目录前按这三样归拢同一次 * 裁决里的几个指标;where 是给人看的说法(「orders」(shop)的业务日期) */ interface Target { table: string; source: string | null; item: string; where: string } /** * 服务端预告的一边。写的:写到哪、写成什么(value 是给人看的写法,raw 是原样的取值,和别的指标的说法比是不是同一个时 * 用)。不写的:reason 是服务端的原话;认出了事实、只是被目录挡下的(已确认、驳回过、和已有条件合不起来)另带 target * 和本来要写的 raw——服务端照样会把它和落到同一项上的别的指标归拢,卡上据此认同一项上有谁 */ type PreviewSide = | { write: true; target: Target; value: string; raw: unknown } | { write: false; target: Target | null; reason: string | null; raw?: unknown } interface CatalogPreview { a: PreviewSide; b: PreviewSide } /** * 对照工件里的 catalog_joint(dual_check_facts.preview_joint):几个指标按各自的选择落到同一项上时,服务端按真写的办法 * 算好的每个指标的结果。members 是落到这一项上的指标和各自的选择,outcomes 按指标 id 给结果 */ interface JointOutcome { write: boolean; raw?: unknown; reason?: string | null } interface JointEntry { source: string | null; table: string; item: string; members: Map; outcomes: Map } const str = (v: unknown): string | undefined => (typeof v === 'string' && v ? v : undefined) const isRecord = (v: unknown): v is Record => !!v && typeof v === 'object' && !Array.isArray(v) const num = (v: unknown): number | undefined => (typeof v === 'number' && Number.isFinite(v) ? v : undefined) const hasSql = (v: unknown): boolean => typeof v === 'string' && !!v.trim() /** payload.summary 里认得出的项(老服务端、写坏了的项跳过,不让整张卡崩掉) */ function summaryOf(raw: unknown): DualCheckSummaryItem[] { return Array.isArray(raw) ? raw.filter((s): s is DualCheckSummaryItem => !!s && typeof s === 'object' && typeof s.metric_id === 'string' && !!s.metric_id) : [] } /** 工件内容像不像一份对照:至少得有 metrics 数组,里面的项带 metric_id */ function cardOf(content: unknown): Card | null { if (!content || typeof content !== 'object' || !Array.isArray((content as Card).metrics)) return null const card = content as Card return { ...card, metrics: card.metrics.filter((m) => !!m && typeof m === 'object' && typeof m.metric_id === 'string') } } /** * 兜底、解析失败的原话 → standard:其中有那句固定的兜底说明(几个输入合并时前面带「输入「…」:」);notes:其余的 * 说法,去掉句末的「请对照原文」(对照就在下面),去重 */ function notesOf(texts: string[]): { standard: boolean; notes: string[] } { const plain = [...new Set(texts.map((t) => t.replace(/,?请对照原文。?$/, '').trim()).filter(Boolean))] const isStandard = (t: string) => t.replace(/^输入「[^」]*」:/, '') === T.fallbackOnly return { standard: plain.some(isStandard), notes: plain.filter((t) => !isStandard(t)) } } /** * 服务端没有预告时(老服务端),审核人的选择可能被记进数据目录的形状:照服务端写目录的门槛(dual_check_facts.derive) * ——两条 SQL 不等价、没用兜底、差异恰好一条,而且是时间列、筛选条件或聚合。几个输入都对不上时节点把各自的差异合成 * 一份(每个输入至少一条),所以「恰好一条」也就是只有一个输入对不上。过了这道门槛也不一定写:只有一边按时间筛、 * 多出的条件是指标自己的范围、采用了不去重的一边都不写,同一次裁决里几个指标给同一张表记的业务日期、去重规则不同时 * 一项都不写,这些卡上看不出来(差异条目只有方面和原话,没有预告也认不出写到哪张表),所以只说必要条件,并把不写的 * 几种照实说出来(DUAL_CHECK_TEXT.approval.catalog) */ function catalogOf(metric: DualCheckMetric, items: { aspect: string; text: string }[]): CatalogAspect | null { if (metric.diff?.equivalent === true || metric.diff?.fallback === true || items.length !== 1) return null return CATALOG_ASPECTS.has(items[0].aspect) ? items[0].aspect as CatalogAspect : null } /** 预告里写到哪:得有表、认得出的目录项;认不出为 null */ function targetOf(s: Record): Target | null { const table = str(s.table) const item = str(s.item) if (!table || !item || !Object.hasOwn(CATALOG_TABLE_FIELD_LABEL, item)) return null const source = str(s.source) ?? null const label = CATALOG_TABLE_FIELD_LABEL[item as keyof typeof CATALOG_TABLE_FIELD_LABEL] return { table, source, item, where: DUAL_CHECK_TEXT.log.catalogItem(table, source ?? undefined, label) } } /** 预告的一边:写的得有写到哪和取值;不写的有没有写到哪都认(老服务端只给原因);认不出返回 undefined */ function previewSideOf(raw: unknown): PreviewSide | undefined { if (!isRecord(raw)) return undefined if (raw.write === false) return { write: false, target: targetOf(raw), reason: str(raw.reason) ?? null, raw: raw.value } const target = targetOf(raw) if (raw.write !== true || !target || raw.value == null || raw.value === '') return undefined return { write: true, target, value: patchValueText(target.item, raw.value), raw: raw.value } } /** * payload.summary[].catalog(约定之外、服务端另带的预告):采用原流程、采用盲算各会往数据目录里写什么,和裁决后真写的 * 是同一套判断。两边有一边认不出就整份不认,卡上回到按差异形状有条件地说(catalogOf)——宁可少说,不替服务端编 */ function previewOf(raw: unknown): CatalogPreview | null { if (!raw || typeof raw !== 'object') return null const a = previewSideOf((raw as Record).a) const b = previewSideOf((raw as Record).b) return a && b ? { a, b } : null } /** 是不是同一个数据源、同一张表的同一项(服务端写目录前按这三样归拢) */ const sameTarget = (a: Pick | null | undefined, b: Pick | null | undefined): boolean => !!a && !!b && a.table === b.table && a.source === b.source && a.item === b.item /** * 对照工件里的 catalog_joint:认不出的条目跳过(宁可这一项回到有条件地说,不替服务端编)。每条要有写到哪、至少两个 * 成员、每个成员都有结果 */ function jointOf(card: Card | null): JointEntry[] { const raw = card?.catalog_joint if (!Array.isArray(raw)) return [] const out: JointEntry[] = [] for (const e of raw) { if (!isRecord(e) || !Array.isArray(e.members) || !isRecord(e.outcomes)) continue const table = str(e.table) const item = str(e.item) if (!table || !item) continue const members = new Map() for (const m of e.members) { if (isRecord(m) && str(m.metric_id) && (m.choice === 'a' || m.choice === 'b')) members.set(m.metric_id as string, m.choice) } const outcomes = new Map() for (const [id, o] of Object.entries(e.outcomes)) { if (isRecord(o) && typeof o.write === 'boolean') outcomes.set(id, { write: o.write, raw: o.value, reason: str(o.reason) ?? null }) } if (members.size < 2 || [...members.keys()].some((id) => !outcomes.has(id))) continue out.push({ source: str(e.source) ?? null, table, item, members, outcomes }) } return out } /** 同一项的两个说法是不是同一个(同服务端的 _same_fact):业务日期只看哪一列,其余是文字、压掉多余的空白比 */ function sameFact(item: string, a: unknown, b: unknown): boolean { if (item === 'business_date') return isRecord(a) && isRecord(b) && a.column === b.column const flat = (s: string) => s.split(/\s+/).filter(Boolean).join(' ') return typeof a === 'string' && typeof b === 'string' && flat(a) === flat(b) } /** 预告里的一条:说什么、这一选会不会写,以及是怎么说出来的(data-* 标记,检查脚本据此核对) */ interface Clause { side: DualCheckChoice text: string write: boolean /** 句子里写明了是哪张表的哪一项:同一项的下一条可以省掉 */ where: boolean /** 服务端说不写、给了原因 */ reason: boolean /** 照服务端算好的合并结果说(catalog_joint) */ joint: boolean /** 合并结果里和别的指标一起记入 */ together: boolean /** * 没有算好的合并结果、按其余指标当前的选择推的:说法不同都不记(conflict)、有效记录条件合写(joined)、同一项上有被 * 目录挡下的指标,写不写说不准、只说可能(pending)。inferred:这一条是推出来的(以上几种,以及推的路上照单个指标的 * 预告说的),结尾换成「以时间线上的记录为准」的一般说法 */ conflict: boolean joined: boolean pending: boolean inferred: boolean } /** * 每个指标三个选择各一条预告。预告是每个指标单独算的,服务端写目录前却把同一次裁决里落到同一张表同一项上的说法归拢成 * 一项(dual_check_facts._merged、_screen、_plan)。按其余指标当前的选择,找出这一选落到同一项上的指标(选了 a、b, * 那一边认出了写到哪的;被目录挡下的也算——服务端照样并进来): * - 只有它自己:照它自己的预告说,会写的说会记为什么,不写的说原因; * - 还有别的:照对照工件里服务端为这几个成员算好的那一条(catalog_joint)说,会写的是合起来的值、写明和谁一起记, * 不写的照原因说;工件里没有(老服务端、组合太多、工件还没取到)时照服务端归拢的先后推(inferred),被目录挡下的 * 同项指标也算进来——服务端先归拢、后对目录: * - 业务日期、去重规则:有一个说法不同(不论它会不会被目录挡下),归拢就失败,都不记;说法都一样时结果和单个指标 * 一样(同一个说法对同一份目录),照自己的预告说; * - 有效记录条件:自己被挡下的,合起来也写不进去(驳回过的会被拿掉,别的原因连合起来的整句一起挡下),照自己的原因说; * 同项上有别的指标被挡下时说不准(挡下它的若是驳回,拿掉它照写;若是别的原因,这一边也一起挡下),只说可能; * 都会写、条件不同的说合成一句 * 推出来的不是服务端算好的结果,结尾换成以时间线上的记录为准的一般说法 */ function clausesOf(view: MetricView, views: MetricView[], choices: Record, joint: JointEntry[]): Clause[] { const P = T.catalogPreview const blank = { write: false, where: false, reason: false, joint: false, together: false, conflict: false, joined: false, pending: false, inferred: false, } const skip = (side: DualCheckChoice): Clause => ({ side, text: P.skip(T.choices[side]), ...blank }) const out: Clause[] = [] for (const side of ['a', 'b'] as const) { const mine = view.preview?.[side] if (!mine) { out.push(skip(side)); continue } const blocked = (reason: string | null | undefined): Clause => (reason ? { side, text: P.blocked(T.choices[side], reason), ...blank, reason: true } : skip(side)) // 前一条已经写明了是哪张表的哪一项,这一条省掉 const short = side === 'b' && !!out[0]?.where && sameTarget(view.preview?.a.target, mine.target) const writing = (value: string, extra: Partial = {}, tail = ''): Clause => ({ side, ...blank, write: true, where: !short, ...extra, text: (short ? P.writeSame(T.choices[side], value) : P.write(T.choices[side], mine.target!.where, value)) + tail, }) const peers = mine.target ? views.filter((o) => { const c = choices[o.id] return o.id !== view.id && (c === 'a' || c === 'b') && sameTarget(o.preview?.[c]?.target, mine.target) }) : [] if (!peers.length) { out.push(mine.write ? writing(mine.value) : blocked(mine.reason)) continue } const members = new Map([[view.id, side], ...peers.map((o) => [o.id, choices[o.id]] as [string, DualCheckChoice])]) const entry = joint.find((e) => sameTarget(e, mine.target) && e.members.size === members.size && [...members].every(([id, c]) => e.members.get(id) === c)) const outcome = entry?.outcomes.get(view.id) if (entry && outcome) { if (!outcome.write || outcome.raw == null || outcome.raw === '') { out.push({ ...blocked(outcome.reason), joint: true }) continue } // 一起记入的:结果也是写的那几个成员(拿掉驳回的、没写进去的不算) const with_ = peers.filter((o) => entry.outcomes.get(o.id)?.write).map((o) => o.name) out.push(writing(patchValueText(entry.item, outcome.raw), { joint: true, together: with_.length > 0 }, with_.length ? P.together(P.metricNames(with_)) : '')) continue } // 没有算好的合并结果:照服务端归拢的先后推。同项上的指标不论会写还是被挡下都带着本来要写的说法(raw),一起算 const item = mine.target!.item const theirs = peers.map((o) => ({ name: o.name, side: o.preview![choices[o.id] as 'a' | 'b']! })) // 认不出本来要写什么(没带 raw)的不算说法不同:说不准,落到下面的「可能」里 const differ = [...new Set(theirs.filter((t) => t.side.raw != null && !sameFact(item, t.side.raw, mine.raw)).map((t) => t.name))] const held = [...new Set(theirs.filter((t) => !t.side.write).map((t) => t.name))] const inferred = { inferred: true } if (differ.length && item !== 'valid_filter') { // 业务日期、去重规则说法不同:归拢这一步就不写了,轮不到对目录,挡下的那个也一样 const names = P.metricNames(differ) out.push({ side, ...blank, ...inferred, conflict: true, where: !short, text: short ? P.conflictSame(T.choices.b, names) : P.conflict(T.choices[side], mine.target!.where, names) }) continue } if (!mine.write) { out.push({ ...blocked(mine.reason), ...inferred }); continue } if (held.length) { const names = P.metricNames(held) out.push({ side, ...blank, ...inferred, pending: true, where: !short, text: short ? P.pendingSame(T.choices[side], mine.value, names) : P.pending(T.choices[side], mine.target!.where, mine.value, names) }) continue } out.push(differ.length ? writing(mine.value, { ...inferred, joined: true }, P.joined(P.metricNames(differ))) : writing(mine.value, inferred)) } out.push(skip('neither')) return out } function viewsOf(summary: DualCheckSummaryItem[], card: DualCheckCard | null): MetricView[] { const full = new Map((card?.metrics ?? []).map((m) => [m.metric_id, m])) // 先按摘要的顺序,工件里另有的(约定里不该有,有就照实列出来)跟在后面 const ids = [...new Set([...summary.map((s) => s.metric_id), ...full.keys()])] return ids.map((id) => { const s = summary.find((x) => x.metric_id === id) const f = full.get(id) ?? null const base = { id, name: str(s?.name) ?? str(f?.name) ?? id, original: str(s?.original_rendered) ?? str(f?.original?.rendered) ?? null, blind: str(s?.blind_rendered) ?? str(f?.blind?.rendered) ?? null, deltaPct: s && 'delta_pct' in s ? num(s.delta_pct) ?? null : f?.delta_pct === null ? null : num(f?.delta_pct), // 预告跟着摘要来:完整对照还没到、或者取不到时也照它说 preview: previewOf(s?.catalog), } if (f) { const items = (Array.isArray(f.diff?.items) ? f.diff.items : []) .filter((i) => !!i && typeof i.text === 'string' && !!i.text && typeof i.aspect === 'string') const concrete = items.filter((i) => !NOT_CONCRETE.has(i.aspect)) const other = items.filter((i) => i.aspect === 'other') const equivalent = f.diff?.equivalent === true const fallbackOnly = !equivalent && !concrete.length const { standard, notes } = notesOf(items.filter((i) => NOT_CONCRETE.has(i.aspect)).map((i) => i.text)) // 对不上的输入里没有一个两边都有 SQL 的(节点的原话「有一边没有可比较的 SQL」):不说「两条 SQL 的写法不同」 const comparable = pairsOf(f).some((p) => p.differs && hasSql(p.original?.sql) && hasSql(p.blind?.sql)) return { ...base, items: concrete.map((i) => i.text), fallbackOnly, fallbackHead: !notes.length || standard || comparable, notes: fallbackOnly ? notes : [], rest: concrete.length && other.length ? other.map((i) => i.text).join(';') : null, equivalent, catalog: catalogOf(f, items), full: f, } } // 只有摘要:服务端把兜底和解析失败都算作 fallback,diff 里是前几条差异的原话 const texts = Array.isArray(s?.diff) ? s.diff.filter((t): t is string => typeof t === 'string' && !!t) : [] const fallbackOnly = s?.fallback === true return { ...base, items: fallbackOnly ? [] : texts, fallbackOnly, fallbackHead: true, notes: fallbackOnly ? notesOf(texts).notes : [], rest: null, equivalent: false, catalog: null, full: null, } }) } /** 相差比例:服务端给的已乘过 100、保留两位(12.5 是相差 12.5%),带正负号;小到两位小数写不出来的写「<0.01%」 */ function deltaText(pct: number | null | undefined): string | null { if (pct === undefined) return null if (pct === null) return T.deltaZero const abs = Math.abs(pct) const sign = pct > 0 ? '+' : pct < 0 ? '-' : '' return T.delta(abs < 0.01 ? `${sign}<0.01%` : `${sign}${abs.toLocaleString('en-US', { maximumFractionDigits: 2 })}%`) } /** * 这次运行里节点的「未采用原流程时」。服务端在 payload 里带了实际生效的处置(given,约定之外另带的)就照它说; * 老服务端不带,从运行的图快照(GET /runs/{id}/graph)里按节点 id 读:没写、写了认不出的按缺省的 degrade(节点执行时 * 同样这么认);图里找不到这个节点(子工作流里的)、图快照取不到时是 unknown,卡上有条件地说 */ type OnReject = 'degrade' | 'fail' | 'unknown' | 'loading' function useOnReject(runId: string, nodeId: string | undefined, given: unknown): OnReject { const known = given === 'fail' || given === 'degrade' ? given : null const key = `${runId}\n${nodeId ?? ''}` const [got, setGot] = useState<{ key: string; value: OnReject } | null>(null) useEffect(() => { if (known || !runId || !nodeId) return let alive = true api.runs.graph(runId).then( (res) => { const node = Array.isArray(res?.graph?.nodes) ? res.graph.nodes.find((n) => n?.id === nodeId) : undefined const value: OnReject = !node ? 'unknown' : node.data?.config?.on_reject === 'fail' ? 'fail' : 'degrade' if (alive) setGot({ key, value }) }, () => { if (alive) setGot({ key, value: 'unknown' }) }, ) return () => { alive = false } }, [known, runId, nodeId, key]) if (known) return known if (!runId || !nodeId) return 'unknown' return got?.key === key ? got.value : 'loading' } /** * 审批卡里双盲复算那一块(RunPanel 的 ApprovalCard 在 payload.kind === 'dual_check' 时渲染它,通用的输入框、备注和 * 「提交 / 驳回并终止」不画——mode 是 input,通用那套会把一个字符串当 value 发出去)。 * * 先按 payload.summary 画:两个值、相差多少、摘要里的差异,选择也能先做;完整对照(card_artifact)到了再补上盲算模型、 * 全部具体差异和「对照两条 SQL」。取不到完整对照时照实说,按摘要照样能裁决。每个指标三选一、缺一个都不能提交, * 回复走审批接口:value 为 {choices, note}。摘要和工件里都认不出指标时没法裁决,只留「驳回并终止」(approved 为假, * 节点按人工驳回失败),免得运行一直挂着 */ export function DualCheckApproval({ approval, onResolved }: DualCheckApprovalProps) { const toast = useToast() const refreshApprovals = useCatalog((s) => s.refreshApprovals) const attachRun = useStudio((s) => s.attachRun) const uid = useId() const payload = approval.payload ?? {} const summary = useMemo(() => summaryOf(payload.summary), [payload.summary]) const cardId = str(payload.card_artifact) ?? '' const onReject = useOnReject(approval.run_id, str(payload.node_id) ?? str(approval.node_id), payload.on_reject) const [card, setCard] = useState<{ id: string; data?: Card | null } | null>(null) useEffect(() => { if (!cardId) return let alive = true setCard({ id: cardId }) api.artifact(cardId).then( (res) => { if (alive) setCard({ id: cardId, data: cardOf(res?.content) }) }, // 取不到(工件被清理、网络断了)和取回来认不出一样处理:按摘要裁决 () => { if (alive) setCard({ id: cardId, data: null }) }, ) return () => { alive = false } }, [cardId]) const slot = card?.id === cardId ? card : null const data = slot?.data ?? null const loading = !!cardId && slot?.data === undefined const lost = !cardId || slot?.data === null const views = useMemo(() => viewsOf(summary, data), [summary, data]) const [choices, setChoices] = useState>({}) const [note, setNote] = useState('') const [busy, setBusy] = useState(false) const pending = views.filter((v) => !choices[v.id]).length // 预告要按其余指标当前的选择算:几个指标落到同一项上时照完整对照里服务端算好的合并结果说,选择一变,各块跟着变 const joint = useMemo(() => jointOf(data), [data]) const clauses = useMemo(() => new Map(views.map((v) => [v.id, clausesOf(v, views, choices, joint)])), [views, choices, joint]) /** 提交裁决(approved 为真,value 是 {choices, note})或驳回(认不出指标时的出口) */ const send = async (approved: boolean) => { if (busy || (approved && (pending || !views.length))) return setBusy(true) try { const value: DualCheckReply = { choices: Object.fromEntries(views.map((v) => [v.id, choices[v.id]])), note: note.trim(), } // 照 ApprovalCard 里 mode 为 input 时的写法:备注外层也放一份,节点拿到的是 {approved, note, value} await api.approvals.decide(approval.id, approved ? { approved: true, note: value.note, value } : { approved: false, note: value.note }) await refreshApprovals() if (onResolved) await onResolved(approval.run_id) else await attachRun(approval.run_id) // 采用盲算、两边都不对时,节点设为「判为失败」就会让运行终止:提示照节点的设置说,读不到设置时不替它下结论 const rejected = Object.values(value.choices).some((c) => c !== 'a') toast(!approved ? T.rejected : !rejected || onReject === 'degrade' ? T.done : onReject === 'fail' ? T.doneFail : T.doneUnknown, 'ok') } catch (e) { toast.error(e) } finally { setBusy(false) } } const noteField = (