不是每句话都值得跑一遍库:模型自己选要不要执行

以前必执行——final 一到就无条件 launch。库里那条会话 7 轮全建了图、全跑了
一遍 153 张表的库,其中:

- 「重试」「继续找找」这种对过程说的话,各自重建了一整张图去查
- 一句明确要「设计一个工作流,使得每次执行的时候都给出管理员账户信息」的,
  建完也直接跑了——用户要的是那张图,不是这一次的结果

流协议给模型两个新出口,三条路径二选一:

- {"op":"reply","text":"…"}  不建图不跑。问的是前几轮已经查出来的东西
  (口径、怎么算的),或者是对过程说的话,或者需要先反问清楚
- done 里 run:false          建图但停住,界面上给「跑一下」
- done 里 run:true(默认)   不变

reply 一到服务端就收流:让它走到后面那套排版校验上,空图会撞出"图校验未
通过:图是空的,先拖一个节点进来"——上一个提交刚治过同类的坑。

放开「直接回答」等于绕开了这条路径上最硬的一条约定(涉及数据必须真查),
所以两头都上:prompt 里写死 reply 只能复述或解释前面几轮已有的结果、不得
新断言任何数据事实,凡是要动到库才知道的哪怕觉得上一轮见过也重新查;界面
上那一轮的结论**前面**挂一条声明,说清楚这一条没有查库。check-stream 里有
一条断言专门盯它排在结论前面——排在后面等于先让人读完再说来源不可靠。

需要留意:这依赖模型照约定表态,不是硬规则。判断跑偏的话收紧那几句约定。
This commit is contained in:
ThearchyHelios
2026-09-18 22:30:45 +08:00
parent 152264b29c
commit cd7ced7673
7 changed files with 202 additions and 10 deletions
+10
View File
@@ -95,6 +95,13 @@ function longReport(): string {
].join("\n")
}
/** 直接回答的那一轮:没查库,界面上必须说破 */
const NO_QUERY_TURN: StreamTurn = {
id: "noquery", question: "刚才那 6 个管理员是怎么算的?", phase: "done", status: "完成",
steps: [], noQuery: true,
output: { answer: "第 1 轮走的是 `role.level IN (platform, regional)` 这个口径。要换口径我重新查一遍。" },
}
const LONG_TURN: StreamTurn = {
id: "long", question: "需要能够显示总结内容", phase: "done", status: "完成",
steps: [], output: { result: longReport() },
@@ -138,6 +145,9 @@ function Preview() {
if (params.get('long') === '1') {
return <AssistantStream turns={[LONG_TURN]} />
}
if (params.get('noquery') === '1') {
return <AssistantStream turns={[NO_QUERY_TURN]} />
}
return (
<div className="flex h-full flex-col">
+17 -4
View File
@@ -1,5 +1,5 @@
import { useEffect, useMemo, useState } from 'react'
import { Database, ListTree, MessageSquare, Send, Square } from 'lucide-react'
import { Database, ListTree, MessageSquare, Play, Send, Square } from 'lucide-react'
import { api } from '../api/client'
import { ApprovalCard } from '../run/RunPanel'
import { AssistantStream, StreamEmpty, type StreamTurn } from '../run/AssistantStream'
@@ -25,7 +25,7 @@ import { useToast } from '../components/ui'
* dense 一个开关。两边各写一套的话,同一次运行在两个页面会讲出不同的故事。
*/
export function ChatPage() {
const { busy, ask, stop, load, loadSteps, turnsOf } = useChat()
const { busy, ask, stop, load, loadSteps, runNow, turnsOf } = useChat()
const currentId = useConversations((s) => s.currentId)
const create = useConversations((s) => s.create)
const turns = useChat((s) => (currentId ? s.byConversation[currentId] : undefined))
@@ -73,6 +73,11 @@ export function ChatPage() {
? () => void loadSteps(currentId, t.id)
: undefined
}
onRun={
currentId && turnsOf(currentId).find((x) => x.id === t.id)?.pendingRun
? () => runNow(currentId, t.id)
: undefined
}
/>
)}
onOpenGraph={(graph) => {
@@ -132,6 +137,7 @@ function toStreamTurn(turn: ChatTurn): StreamTurn {
phase: turn.phase === 'waiting' ? 'waiting'
: turn.phase === 'error' ? 'error'
: running ? 'running' : 'done',
// ready(建好了没跑)在流里按"完成"画,差别体现在下面那个「跑一下」上
status: turn.status,
// 建图的步骤在前,跑图的在后——这正是发生的顺序
steps: [...decodeCopilot(turn.ops), ...decodeRun(turn.events)],
@@ -142,6 +148,7 @@ function toStreamTurn(turn: ChatTurn): StreamTurn {
runClass: turn.run?.run_class,
graph: turn.graph,
graphNote: turn.explanation,
noQuery: turn.noQuery,
}
}
@@ -151,19 +158,25 @@ function toStreamTurn(turn: ChatTurn): StreamTurn {
* 从库里恢复的轮次没有事件流——一次会话几十轮,把每轮的事件都预加载回来
* 是几十个请求换一堆没人看的步骤。所以默认只显示问题和答案,想看过程再取。
*/
function Approvals({ turnId, runId, onShowSteps }: {
function Approvals({ turnId, runId, onShowSteps, onRun }: {
turnId: string
runId?: string
onShowSteps?: () => void
onRun?: () => void
}) {
const conversationId = useConversations((s) => s.currentId)
const approvals = useCatalog((s) => s.approvals)
const reattach = useChat((s) => s.reattach)
const pending = approvals.filter((a) => a.run_id === runId && a.status === 'pending')
if (!runId) return null
if (!runId && !onRun) return null
return (
<>
{onRun && (
<button className="btn btn-xs btn-primary mt-2 gap-1 text-[11px]" onClick={onRun}>
<Play size={11} /> 跑一下
</button>
)}
{onShowSteps && (
<button className="btn btn-xs btn-ghost mt-2 gap-1 text-[11px]" onClick={onShowSteps}>
<ListTree size={11} /> 看执行过程
+14 -1
View File
@@ -1,7 +1,7 @@
import { useEffect, useRef, useState, type ReactNode } from 'react'
import {
Brain, ChevronRight, CircleCheck, CircleDot, Database,
FileCode, GitBranch, Hand, Sparkles, Table2, Terminal, Wrench, XCircle,
FileCode, GitBranch, Hand, Info, Sparkles, Table2, Terminal, Wrench, XCircle,
} from 'lucide-react'
import clsx from 'clsx'
import { Spinner } from '../components/ui'
@@ -40,6 +40,8 @@ export interface StreamTurn {
/** 这一轮建出来的图,可展开看、可放到画布 */
graph?: any
graphNote?: string
/** 这一条没有查库,答案是根据前几轮说的 */
noQuery?: boolean
}
const ICONS: Record<StepKind, typeof Wrench> = {
@@ -143,6 +145,17 @@ function TurnCard({ turn, dense, approvals, onOpenGraph }: {
{approvals}
{/* 没查库这件事必须说在结论前面。「涉及数据必须真查」是这条路径上
最硬的一条约定,放开它之后,用户得能一眼分清哪些结论背后真的
动了库、哪些只是在复述前面几轮 */}
{turn.noQuery && (
<div className="mt-2 flex items-start gap-1.5 rounded border px-2 py-1.5 text-[10.5px] leading-relaxed"
style={{ borderColor: 'var(--border)', color: 'var(--text-dim)' }}>
<Info size={11} className="mt-[2px] shrink-0" />
<span>这一条没有查库,是根据前面几轮的结果说的</span>
</div>
)}
{turn.output && (
<Output output={turn.output} dense={dense} runClass={turn.runClass} />
)}
+48 -2
View File
@@ -30,6 +30,7 @@ export type Phase =
| 'building' // 图在长出来
| 'running' // 图在跑
| 'waiting' // 停在人工介入
| 'ready' // 图建好了,等用户决定跑不跑
| 'done'
| 'error'
@@ -61,6 +62,10 @@ export interface ChatTurn {
/** 这一轮自己的取消句柄。放 turn 上而不是 store 上:store 单值会被
* 下一轮 ask 覆盖,上一轮的 WebSocket 就再也关不掉了 */
cancel: (() => void) | null
/** 这一轮没有查库,答案是根据前几轮说的。界面上必须标出来 */
noQuery?: boolean
/** 图建好了但按模型的意思没有自动跑,等用户点「跑一下」 */
pendingRun?: boolean
/** 从库里恢复的历史轮次。它没有事件流,步骤要点开才去取 */
restored?: boolean
/** 已经补取过事件(或正在取),别重复拉 */
@@ -82,6 +87,8 @@ interface ChatState {
reattach: (conversationId: string, turnId: string) => Promise<void>
/** 历史轮次点开"执行过程"时才去取事件 */
loadSteps: (conversationId: string, turnId: string) => Promise<void>
/** 模型建了图但没自动跑时,用户点「跑一下」 */
runNow: (conversationId: string, turnId: string) => void
/** 会话被删了,把内存里那一桶也丢掉 */
forget: (conversationId: string) => void
}
@@ -95,6 +102,7 @@ const PHASE_TEXT: Record<Phase, string> = {
building: '正在搭建流程…',
running: '正在执行…',
waiting: '等待你的确认',
ready: '流程搭好了,没有自动执行',
done: '完成',
error: '出错了',
}
@@ -272,14 +280,37 @@ export const useChat = create<ChatState>((set, get) => ({
case 'done':
patch(() => ({ explanation: op.explanation ?? '' }))
break
case 'reply': {
// 这句话不需要工作流——问的是前几轮已经查出来的东西,或者是
// 对过程说的话(「重试」「换个说法」)。以前这些也各自重建一整张
// 图、跑一遍 153 张表的库,纯属白花钱
const text = String(op.text ?? '')
patch(() => ({
phase: 'done', status: PHASE_TEXT.done,
output: { answer: text }, noQuery: true,
}))
set({ busy: false, cancel: null })
void save({ status: 'done', answer: text })
break
}
case 'final': {
// 后端排版校验后的最终图。拿到它就可以直接跑了
const graph = op.graph as GraphSpec
void save({ graph, explanation: op.explanation ?? '' })
// 用户要的是流程本身时(「设计一个每天跑的工作流」),建完就跑
// 等于替他多花一次钱,而他要的是那张图
if (op.autorun === false) {
patch(() => ({
graph, phase: 'ready', status: PHASE_TEXT.ready,
explanation: op.explanation ?? '', pendingRun: true,
}))
set({ busy: false, cancel: null })
void save({ status: 'done' })
break
}
patch(() => ({
graph, phase: 'running', status: PHASE_TEXT.running,
explanation: op.explanation ?? '',
}))
void save({ graph, explanation: op.explanation ?? '' })
void launch(conversationId, id, graph, question, patch, set, save)
break
}
@@ -327,6 +358,21 @@ export const useChat = create<ChatState>((set, get) => ({
}))
},
runNow: (conversationId, turnId) => {
const turn = get().byConversation[conversationId]?.find((t) => t.id === turnId)
if (!turn?.graph || get().busy) return
const patch = patcher(set, conversationId, turnId)
const save = async (body: Record<string, any>) => {
if (!turn.serverId) return
try {
await api.conversations.patchTurn(conversationId, turn.serverId, body)
} catch { /* 存不下不该影响这次运行 */ }
}
patch(() => ({ phase: 'running', status: PHASE_TEXT.running, pendingRun: false }))
set({ busy: true })
void launch(conversationId, turnId, turn.graph, turn.question, patch, set, save)
},
reattach: async (conversationId, turnId) => {
const turn = get().byConversation[conversationId]?.find((t) => t.id === turnId)
if (!turn?.run) return