From ee6e07959b7825fed186652a94ec7761854566bb Mon Sep 17 00:00:00 2001 From: ThearchyHelios Date: Fri, 16 Oct 2026 10:59:15 +0800 Subject: [PATCH] =?UTF-8?q?=E9=97=AE=E6=95=B0=E6=8D=AE=E4=B8=80=E8=BD=AE?= =?UTF-8?q?=E7=9A=84=E3=80=8C=E5=86=B3=E5=AE=9A=E3=80=8D=E4=B8=8B=E6=B2=89?= =?UTF-8?q?=E5=88=B0=E5=90=8E=E7=AB=AF=20chat/turn.py=EF=BC=8C=E9=97=AE?= =?UTF-8?q?=E6=95=B0=E6=8D=AE=E9=A1=B5=E7=85=A7=E5=90=8E=E7=AB=AF=E7=BB=99?= =?UTF-8?q?=E7=9A=84=E8=B5=B0=EF=BC=88=E7=BB=86=E6=A1=88=2001=20=E5=81=9A?= =?UTF-8?q?=E6=B3=95=201=EF=BC=8C=E6=80=BB=E6=96=B9=E6=A1=88=202.1?= =?UTF-8?q?=EF=BC=89=EF=BC=9B=E8=BF=99=E4=B8=80=E8=BD=AE=E7=9A=84=E8=8A=B1?= =?UTF-8?q?=E8=B4=B9=20=3D=20=E5=8A=A9=E6=89=8B=20+=20=E8=BF=90=E8=A1=8C?= =?UTF-8?q?=20+=20=E5=A4=8D=E6=A0=B8?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - chat/turn.py:next_step(有 error 级问题时自查过就判失败、没自查过的老服务端才重来一次;autorun=false 只建不跑;reply、只有反问直接收尾;其余运行)、fill_input(规则同 chat.ts 的 fillInput)、retry_after_review(retry、broken、这一轮还没试满)、retry_instruction(两种措辞原样搬过来) - answer_ops 的 final(含只问不改那条)带 next(run | ready | fail);/copilot/review 的结果带 retry_instruction(ReviewIn.attempt 按这一轮试过几次判,要重来是那句话,不重来是 null) - 前端 store/chat.ts:final 照 next 走,复核照 retry_instruction 走(原样交回给助手),launch / watch / settle 把 attempt 带到复核;老后端没有这两个字段时退回原来的规则(常量和措辞留在 retryInstruction 里,和后端逐字对照) - 这一轮的用量:usage 操作累加进 copilot,复核结果的 usage 累加进 review,自动重来和用户点重试换下来的运行并进 earlier,当前运行的抄进 run,一起随 meta.usage 落库;问数据页轮次头部写这一轮的花费(runCostText:估不出的写「≥」或「金额无法估算」),悬停分得清助手建图、运行、复核,文案在 lib/terms.ts 的 TURN_COST_TEXT;ReviewResult 类型补 retry_instruction、usage - 新增 tests/test_chat_turn_policy.py(各条决定的分支;前后端对照 MAX_ATTEMPTS、认问题字段的正则、两种重来措辞——改一个字回跑会失败;复核按 attempt 给不给 retry_instruction);test_copilot_answer_ops 的基线比对改成「final 只多一个 next」 - check-chat 补一段「新服务端」:照 next=ready 不发起、照 retry_instruction 原样重来、第二次复核带 attempt=1、meta.usage 四份都记下、头部写 $0.067 且悬停分得清三部分 --- backend/app/api/copilot.py | 9 +- backend/tests/test_chat_turn_policy.py | 202 +++++++++++++++++++++++ backend/tests/test_copilot_answer_ops.py | 10 +- frontend/src/api/client.ts | 3 +- frontend/src/lib/terms.ts | 15 ++ frontend/src/pages/ChatPage.tsx | 28 +++- frontend/src/run/AssistantStream.tsx | 6 +- frontend/src/store/chat.ts | 164 +++++++++++++++--- frontend/src/types.ts | 11 ++ scripts/check-chat.mjs | 84 +++++++++- 10 files changed, 502 insertions(+), 30 deletions(-) create mode 100644 backend/tests/test_chat_turn_policy.py diff --git a/backend/app/api/copilot.py b/backend/app/api/copilot.py index 469e5864..f8b9e200 100644 --- a/backend/app/api/copilot.py +++ b/backend/app/api/copilot.py @@ -1792,11 +1792,13 @@ async def answer_ops(payload: GenerateIn, *, catalog_view: Any = None): 拒绝在这里抛 HTTPException(调用方没迭代到第一条就知道)。catalog_view 是这一轮读哪一份数据目录(data/catalog_view.py: 查看的表详情、自查的 SQL 检查器都按它),不给是当前目录。 - 最后多交一条 usage(providers/usage.py):{op: usage, by_model, input_tokens, output_tokens, calls, cost_usd, + final 带 next(chat/turn.next_step:run 运行、ready 只建不跑、fail 判失败),问数据页照它走。最后多交一条 usage + (providers/usage.py):{op: usage, by_model, input_tokens, output_tokens, calls, cost_usd, unpriced_calls}——这一轮助手建图(含挑表、接着写、自查修正)花了多少。前面每一条和抽出来之前逐条一样。运行不在这里, 不计。 """ from app.api.deps import restricted + from app.chat import turn from app.data.catalog_view import CatalogView from app.data.sqlcheck import load_checkers from app.db.base import SessionLocal @@ -1859,7 +1861,8 @@ async def answer_ops(payload: GenerateIn, *, catalog_view: Any = None): # 先问清楚才能动手,什么都还没改:这一轮到此为止。照样发一条 final 收尾,带上问题(asked)和没动过的图: # 前端据此把这一轮记成「助手反问」、问题进历史(以前流就这么断了,问数据页一直停在「进行中」), # 不运行、不重排。图给一份对象(画布上原来的图、问数据上一轮的图,都没有就是空图),老前端照样认得 - yield _asked_final(gen.asked, payload.base_graph, prev_graph) + asked_final = _asked_final(gen.asked, payload.base_graph, prev_graph) + yield {**asked_final, "next": turn.next_step(asked_final)} return # 只发了目录修改提案,既没回答也没改图(用户只是在说一条数据事实):补一句回答收尾, # 不能按下面的「模型没有给出任何修改」报错——提案已经摆在用户面前了 @@ -1945,6 +1948,8 @@ async def answer_ops(payload: GenerateIn, *, catalog_view: Any = None): # 改了图又问了用户(这一轮照样结束、不自动运行):问题跟着 final 交付,前端记进这一轮 **({"asked": _asked_of(gen.asked)} if gen.asked is not None else {}), } + # 建完之后怎么走(chat/turn.next_step):run 运行、ready 只建不跑、fail 判失败。问数据页照它走,评测用同一个函数 + final["next"] = turn.next_step(final) except Exception as e: # noqa: BLE001 final = {"op": "error", "message": f"模型返回的工作流结构有误:{graph_error(e)}", "hint": "请重试,或把需求描述得更具体", "detail": raw_error(e)} diff --git a/backend/tests/test_chat_turn_policy.py b/backend/tests/test_chat_turn_policy.py new file mode 100644 index 00000000..2f3bd8d1 --- /dev/null +++ b/backend/tests/test_chat_turn_policy.py @@ -0,0 +1,202 @@ +"""问数据一轮的「决定」(app/chat/turn.py;细案 01 做法 1)。 + +要不要运行、输入怎么填、要不要带着原图重来、重来时说什么,从问数据页下沉到后端:final 带 next,复核带 retry_instruction, +问数据页照它们走;老服务端没给这两个字段时,问数据页退回它自己那份同样的规则。这里守: + +- 各条决定的分支(next_step、fill_input、retry_after_review、retry_instruction 的两种措辞); +- 前后端对照:frontend/src/store/chat.ts 里留着的那份常量(MAX_ATTEMPTS、fillInput 认问题字段的正则、两种重来的措辞) + 和这里逐字一致——写法同 test_frontend_type_unions.py,两边一改就对不上; +- /copilot/review 按这一轮试过几次给 retry_instruction:可以重来时是那句话,不重来是 null。 + +问题、字段名都是虚构的。 +""" +from __future__ import annotations + +import re +import uuid +from pathlib import Path + +import pytest +from httpx import ASGITransport, AsyncClient + +from app.chat import turn +from app.main import app + +CHAT_TS = Path(__file__).resolve().parents[2] / "frontend" / "src" / "store" / "chat.ts" + + +def _final(*, issues=(), autorun=True, **extra) -> dict: + return {"op": "final", "graph": {"nodes": [], "edges": []}, "issues": list(issues), "autorun": autorun, **extra} + + +ERROR = {"level": "error", "message": "图是空的"} +WARNING = {"level": "warning", "message": "多余的 {{ }}"} + + +# -------------------------------------------------------------------------- +# next_step +# -------------------------------------------------------------------------- + + +def test_next_step_branches(): + assert turn.next_step(_final()) == "run" + assert turn.next_step(_final(issues=[WARNING])) == "run", "warning 不挡运行" + assert turn.next_step(_final(autorun=False)) == "ready", "模型说不运行:只建不跑" + assert turn.next_step(_final(autorun=False, asked={"question": "哪个月?", "options": []})) == "ready" + assert turn.next_step(_final(issues=[ERROR])) == "fail", "自查过还有 error:判失败,不再整轮重来" + assert turn.next_step(_final(issues=[ERROR]), self_checked=False) == "retry", "老服务端没自查:重来一次" + assert turn.next_step(_final(issues=[ERROR], autorun=False)) == "fail", "没过检查比只建不跑优先" + assert turn.next_step({"op": "reply", "text": "已经查过了"}) == "reply" + assert turn.next_step({"op": "error", "message": "x"}) == "fail" + assert turn.next_step(None) == "asked", "流结束时只有反问" + assert set(turn.NEXT_STEPS) == {"run", "ready", "fail"} + + +# -------------------------------------------------------------------------- +# fill_input +# -------------------------------------------------------------------------- + + +def _graph(*fields: dict) -> dict: + return {"nodes": [{"id": "start", "type": "input", "data": {"label": "输入", "config": {"fields": list(fields)}}}, + {"id": "out", "type": "output", "data": {"label": "成果", "config": {}}}], "edges": []} + + +def test_fill_input_rules(): + assert turn.fill_input(_graph(), "上周销售额", "问:…") == {"question": "上周销售额", "history": "问:…"} + assert turn.fill_input({"nodes": []}, "上周销售额") == {"question": "上周销售额", "history": ""} + # 名字像「问题」的优先,其余字段填默认值(没有就空串) + got = turn.fill_input(_graph({"name": "region", "default": "华东"}, {"name": "topic"}, {"name": "limit"}), "退款率") + assert got == {"history": "", "region": "华东", "topic": "退款率", "limit": ""} + got = turn.fill_input(_graph({"name": "门店"}, {"name": "需求说明"}), "退款率") + assert got["需求说明"] == "退款率" and got["门店"] == "" + # 没有像问题的:第一个必填的;再没有:第一个 + got = turn.fill_input(_graph({"name": "a"}, {"name": "b", "required": True}), "退款率") + assert got["b"] == "退款率" and got["a"] == "" + got = turn.fill_input(_graph({"name": "a"}, {"name": "b"}), "退款率") + assert got["a"] == "退款率" + # 大小写不敏感 + assert turn.fill_input(_graph({"name": "UserQuery"}), "退款率")["UserQuery"] == "退款率" + + +# -------------------------------------------------------------------------- +# 复核之后:要不要重来、说什么 +# -------------------------------------------------------------------------- + + +BROKEN = {"retry": True, "severity": "broken", "note": "结论不可用", + "signals": [{"kind": "step_limit", "detail": "agent 用满了 8 步"}, {"kind": "tool_error", "detail": "表不存在"}]} + + +def test_retry_after_review(): + assert turn.retry_after_review(BROKEN, 0) is True + assert turn.retry_after_review(BROKEN, 1) is False, "一轮最多自动再试一次" + assert turn.retry_after_review({**BROKEN, "severity": "degraded"}, 0) is False + assert turn.retry_after_review({**BROKEN, "retry": False}, 0) is False + assert turn.retry_after_review(None, 0) is False + assert turn.review_reason(BROKEN) == "agent 用满了 8 步;表不存在" + assert turn.review_reason({"signals": [], "note": "结论不可用"}) == "结论不可用" + + +def test_retry_instruction_two_wordings(): + with_base = turn.retry_instruction("上周销售额", "表不存在", True) + assert with_base.startswith("这个工作流上一次运行没有成功:表不存在。\n\n请针对这个原因改它") + assert with_base.endswith("改完继续回答原来的问题:上周销售额") + scratch = turn.retry_instruction("上周销售额", "表不存在", False) + assert scratch == "上周销售额\n\n(上一次没有成功:表不存在。请针对这个原因调整,重新给出完整的工作流。)" + + +# -------------------------------------------------------------------------- +# 前后端对照 +# -------------------------------------------------------------------------- + + +def _ts() -> str: + return CHAT_TS.read_text(encoding="utf-8") + + +def test_max_attempts_matches_the_frontend(): + found = re.search(r"const MAX_ATTEMPTS = (\d+)", _ts()) + assert found and int(found.group(1)) == turn.MAX_ATTEMPTS + + +def test_the_question_field_pattern_matches_the_frontend(): + found = re.search(r"/(question\|[^/]+)/i\.test", _ts()) + assert found, "chat.ts 的 fillInput 里找不到认问题字段的正则" + assert found.group(1) == turn.QUESTION_FIELD.pattern and turn.QUESTION_FIELD.flags & re.IGNORECASE + + +def _template(source: str) -> str: + """一段 TS 里由 + 连起来的模板字符串 → 一个 Python format 模板(${x} → {x},\\n → 换行)。""" + pieces = re.findall(r"`([^`]*)`", source) + text = "".join(pieces).replace("\\n", "\n") + return re.sub(r"\$\{(\w+)\}", r"{\1}", text) + + +def test_the_retry_wordings_match_the_frontend(): + body = re.search(r"function retryInstruction\([^)]*\): string \{(.*?)\n\}", _ts(), re.S) + assert body, "chat.ts 里找不到 retryInstruction" + with_base, scratch = re.split(r"\n\s*: ", body.group(1).split("hasBase", 1)[1].split("?", 1)[1], maxsplit=1) + assert _template(with_base) == turn.RETRY_WITH_BASE + assert _template(scratch) == turn.RETRY_FROM_SCRATCH + + +# -------------------------------------------------------------------------- +# /copilot/review 给 retry_instruction +# -------------------------------------------------------------------------- + + +@pytest.fixture +async def client(): + async with AsyncClient(transport=ASGITransport(app=app), base_url="http://test") as c: + yield c + + +async def _run(output: dict, graph: dict, code: str) -> str: + from app.core.events import EventType + from app.db.base import SessionLocal + from app.db.models import Run, RunEvent + + async with SessionLocal() as session: + run = Run(id=uuid.uuid4().hex, status="succeeded", output=output, graph=graph) + session.add(run) + await session.flush() + session.add(RunEvent(run_id=run.id, seq=1, type=EventType.LOG, node_id="a", ts=0.0, + data={"level": "warn", "code": code, "message": "agent 用满了 8 步还没给出结论"})) + await session.commit() + return run.id + + +async def test_review_says_whether_and_how_to_retry(client, monkeypatch): + import app.api.copilot as copilot + from app.providers.factory import ProviderNotConfigured + + async def unconfigured(*_a, **_k): + raise ProviderNotConfigured("没有可用的 provider") + + # 没配模型:规则层照样判得出不可用、该重来 + monkeypatch.setattr(copilot, "get_chat_model", unconfigured) + graph = _graph({"name": "question"}) + run_id = await _run({"answer": "大概 3 家"}, graph, "step_limit") + body = (await client.post("/api/copilot/review", json={"run_id": run_id, "question": "有几家门店"})).json() + assert body["severity"] == "broken" and body["retry"] is True + assert body["retry_instruction"] == turn.retry_instruction("有几家门店", turn.review_reason(body), True) + # 这一轮已经重来过一次:不再给 + body = (await client.post("/api/copilot/review", + json={"run_id": run_id, "question": "有几家门店", "attempt": 1})).json() + assert body["retry_instruction"] is None + # 运行的图是空的:措辞换成从零再建 + bare = await _run({"answer": "大概 3 家"}, {}, "step_limit") + body = (await client.post("/api/copilot/review", json={"run_id": bare, "question": "有几家门店"})).json() + assert body["retry_instruction"].startswith("有几家门店\n\n(上一次没有成功:") + # 干净的运行:不重来 + from app.db.base import SessionLocal + from app.db.models import Run + + async with SessionLocal() as session: + clean = Run(status="succeeded", output={"answer": "3 家"}, graph=graph) + session.add(clean) + await session.commit() + clean_id = clean.id + body = (await client.post("/api/copilot/review", json={"run_id": clean_id, "question": "有几家门店"})).json() + assert body["verdict"] == "ok" and body["retry_instruction"] is None diff --git a/backend/tests/test_copilot_answer_ops.py b/backend/tests/test_copilot_answer_ops.py index 4bbd5566..c100b15c 100644 --- a/backend/tests/test_copilot_answer_ops.py +++ b/backend/tests/test_copilot_answer_ops.py @@ -4,7 +4,8 @@ 问数据页照旧收 SSE。这里守: - 几种结局(建图交付、直接回答、只问不改、自查改不好、模型出错、没给操作、输出被截断)的 SSE 输出,和抽出来之前 - 逐条一样(剧本见 SCENARIOS,抽出来之前录下的输出在 fixtures/copilot_answer_ops_baseline.json),末尾只多一条 usage; + 逐条一样(剧本见 SCENARIOS,抽出来之前录下的输出在 fixtures/copilot_answer_ops_baseline.json),末尾只多一条 usage, + final 只多一个 next(问数据一轮的决定,chat/turn.py); - 直接迭代 answer_ops 和 SSE 收到的是同一串; - 开流前的拒绝(模型没配好、限定的数据源都不在)照旧是 HTTP 错误,不进流。 @@ -130,12 +131,19 @@ async def _sse(client, body: dict) -> list[dict]: BODY = {"instruction": "数一数门店", "intent": "answer"} +#: final 带的 next(chat/turn.next_step):问数据页照它走 +NEXT = {"graph_ok": "run", "graph_fixed": "run", "check_failed": "fail", "ask_only": "ready"} + + @pytest.mark.parametrize("name", list(SCENARIOS)) async def test_the_sse_output_is_unchanged_but_for_a_trailing_usage(client, monkeypatch, name): _use(monkeypatch, _Scripted(*SCENARIOS[name])) got = await _sse(client, BODY) expected = json.loads(BASELINE.read_text(encoding="utf-8"))[name] assert got[-1]["op"] == "usage", got[-1] + # final 多了 next(问数据一轮的决定下沉到后端),别的一个字不变 + finals = [op for op in got if op["op"] == "final"] + assert [op.pop("next") for op in finals] == ([NEXT[name]] if name in NEXT else []) assert got[:-1] == expected diff --git a/frontend/src/api/client.ts b/frontend/src/api/client.ts index eafdec5b..079342e4 100644 --- a/frontend/src/api/client.ts +++ b/frontend/src/api/client.ts @@ -880,7 +880,8 @@ export const api = { setModel: (body: { provider?: string | null; model?: string | null }) => put('/copilot/model', body), /** 跑完之后复核一次。干净的运行后端直接返回 verdict='ok',不调模型 */ - review: (body: { run_id: string; question: string }) => + /** attempt:这一轮已经自动试了几次(从 0 数),服务端据此决定给不给 retry_instruction。老服务端不认它,忽略 */ + review: (body: { run_id: string; question: string; attempt?: number }) => post('/copilot/review', body), /** * 一键升级为可追溯结构:先按确定的规则改写(llm 换成报告撰写、问数据的图插入报告节点……), diff --git a/frontend/src/lib/terms.ts b/frontend/src/lib/terms.ts index fd44bf8d..0beb188e 100644 --- a/frontend/src/lib/terms.ts +++ b/frontend/src/lib/terms.ts @@ -759,6 +759,21 @@ export function runCostText(usd: number | null | undefined, unpriced: number, ap return `${(approx || unpriced > 0) && usd > 0 ? '≥ ' : ''}${formatCost(usd)}` } +/** + * 问数据一轮的花费:助手建图(含挑表、接着写、自查修正)+ 运行 + 复核(next-round 细案 01 做法 3)。以前只算运行那份, + * 这一轮的花费是低报的 + */ +export const TURN_COST_TEXT = { + copilot: '助手建图', + run: '运行', + review: '复核', + /** 悬停说明的第一行,parts 是「助手建图 $0.012 · 运行 $0.03 · 复核 $0」 */ + title: (parts: string) => `这一轮的花费:${parts}`, + /** n 次调用的金额估不出来:金额只是下限 */ + unpriced: (n: number) => + `其中 ${formatNumber(n)} 次调用的金额无法估算(模型不在价格目录中,或用量没有报全),未计入,实际花费不低于此数`, +} as const + export const JUDGE_SETTING_TEXT = { label: '证据裁判', hint: '报告中的结论句(如「增长主要来自新客首单」)由另一个模型按证据逐句判断:正式运行由报告撰写节点当场裁判,探索运行在点击时逐句裁判。判断由模型给出,不是系统核对,界面上一律标注「非确定」。', diff --git a/frontend/src/pages/ChatPage.tsx b/frontend/src/pages/ChatPage.tsx index 8bae6511..7ee7c6f1 100644 --- a/frontend/src/pages/ChatPage.tsx +++ b/frontend/src/pages/ChatPage.tsx @@ -17,14 +17,15 @@ import { humanizeError } from '../lib/errors' import { explainRunError } from '../lib/explain' import { canLeave, leavePass } from '../lib/leave' import { formatNumber, formatTime } from '../lib/format' -import { CHAT_BLUEPRINT_TEXT } from '../lib/terms' +import { CHAT_BLUEPRINT_TEXT, TURN_COST_TEXT, runCostText } from '../lib/terms' import { useCatalog, useCatalogListState, useDatasources, useOnReconnect, type CatalogListState } from '../store/catalog' import { useAtLeast } from '../store/auth' import { useBlueprint } from '../store/blueprint' import type { BlueprintScope } from '../typesBlueprint' import { blueprintPath, useCreateScope } from './blueprints/shared' import { - agentSteps, busyTurn, isBusy, stepsVisible, useChat, type Attempt, type ChatTurn, type Failure, type ScopeSource, + agentSteps, busyTurn, isBusy, stepsVisible, turnCost, usageOfTurn, useChat, type Attempt, type ChatTurn, type Failure, + type ScopeSource, } from '../store/chat' import { lastVisited, useConversations } from '../store/conversations' import { @@ -422,11 +423,34 @@ function toStreamTurn(turn: ChatTurn): StreamTurn { // 可能先到一两条事件,流会拿第一步的起点顶上,计时器从提问那天跑起 startedAt: live ? turn.startedAt : null, elapsedMs: !live && turn.endedAt ? turn.endedAt - turn.startedAt : turn.meta?.ms ?? undefined, + cost: costOf(turn), } streamCache.set(turn, out) return out } +/** + * 这一轮的花费(助手建图 + 运行 + 复核,store 的 usageOfTurn):没花钱、也没有估不出的(演示模型、老轮次)不写。 + * 悬停写各部分,估不出的照实说金额只是下限 + */ +function costOf(turn: ChatTurn): StreamTurn['cost'] { + const usage = usageOfTurn(turn) + const total = turnCost(usage) + if (!usage || !total || (!total.usd && !total.unpriced)) return undefined + const text = runCostText(total.usd, total.unpriced) + if (!text) return undefined + const part = (label: string, u: { cost_usd?: number | null; unpriced_calls?: number } | undefined) => + `${label} ${runCostText(u?.cost_usd ?? 0, u?.unpriced_calls ?? 0) ?? '—'}` + const run = turnCost({ earlier: usage.earlier, run: usage.run }) + const parts = [ + part(TURN_COST_TEXT.copilot, usage.copilot), + part(TURN_COST_TEXT.run, run ? { cost_usd: run.usd, unpriced_calls: run.unpriced } : undefined), + part(TURN_COST_TEXT.review, usage.review), + ].join(' · ') + return { text, title: [TURN_COST_TEXT.title(parts), total.unpriced ? TURN_COST_TEXT.unpriced(total.unpriced) : ''] + .filter(Boolean).join('\n') } +} + /** * 交给流里报错块的那份:store 已经拆好的标题、原因、怎么办,照原样画。运行的失败在 * store 里就按 lib/explain 讲过了(和记录页同一套说法),再把原话交过去会被翻第二遍; diff --git a/frontend/src/run/AssistantStream.tsx b/frontend/src/run/AssistantStream.tsx index 18140984..f17d62fc 100644 --- a/frontend/src/run/AssistantStream.tsx +++ b/frontend/src/run/AssistantStream.tsx @@ -119,6 +119,8 @@ export interface StreamTurn { startedAt?: number | null /** 跑完的轮次花了多久(毫秒)。不给就从「完成」那一行推 */ elapsedMs?: number + /** 这一轮的花费(问数据页给:助手建图 + 运行 + 复核)。text 进头部小标签,title 是悬停时各部分的明细 */ + cost?: { text: string; title: string } /** * 头部要不要提醒。phase 只分得出跑没跑完;「图放上去了,但还有 2 处问题」 * 也是 done,头部却不该是一个安静的绿勾 @@ -613,6 +615,7 @@ function TurnHead({ turn }: { turn: StreamTurn }) { progress.total ? `${progress.done}/${progress.total} 节点` : '', !live && queries ? `${queries} 次查询` : '', !live ? took : '', + !live && turn.cost ? turn.cost.text : '', ].filter(Boolean) const fraction = progress.total ? Math.min(1, progress.done / progress.total) : undefined // 节点轨:图不大时一个节点一格,按状态着色——跑到哪、哪一步跳过了、卡在哪一眼看全。 @@ -636,7 +639,8 @@ function TurnHead({ turn }: { turn: StreamTurn }) { {verdict && · {verdict}} {tags.length > 0 && ( - {tags.join(' · ')} + {tags.join(' · ')} )} {tier && ( // 出具档位也挂在吸顶的头上:往下翻到报告中段时,"这份结论能不能当真"还看得见。 diff --git a/frontend/src/store/chat.ts b/frontend/src/store/chat.ts index 6ed4255c..fe7ab6b3 100644 --- a/frontend/src/store/chat.ts +++ b/frontend/src/store/chat.ts @@ -154,6 +154,32 @@ export interface TurnMeta { * 有多久没动静:后端按 updated_at 算,而重试一轮昨天的问题时 created_at 是昨天的 */ at?: number + /** 这一轮的花费:助手建图、运行、复核各一份(next-round 细案 01 做法 3),见 TurnUsage */ + usage?: TurnUsage +} + +/** + * 一份用量:服务端 providers/usage.py 的汇总(助手建图的 usage 操作、复核结果的 usage),或者运行的 usage。cost_usd 只是 + * 估得出的那部分;unpriced_calls 次估不出(模型不在价格目录里,或者用量没报全),这时金额前写「≥」 + */ +export interface UsageTotal { + cost_usd?: number | null + unpriced_calls?: number + calls?: number + input_tokens?: number + output_tokens?: number +} + +/** + * 这一轮的花费 = 助手建图 + 运行 + 复核(以前只有运行那份,问数据的花费是低报的)。自动重来、用户点的重试都还是这一轮: + * 前几次建图、复核累加在 copilot / review 里,被换掉的运行累加在 earlier 里;run 是当前这次运行(落库时从 run.usage 抄一份, + * 恢复的历史轮次不用回源就有数) + */ +export interface TurnUsage { + copilot?: UsageTotal + review?: UsageTotal + earlier?: UsageTotal + run?: UsageTotal } export interface ChatTurn { @@ -227,6 +253,8 @@ export interface ChatTurn { writing?: { chars: number; thought: string } | null /** 这一问只查这几个数据源。重试、重新问都沿用它 */ scope?: ScopeSource[] + /** 这一轮到目前为止的助手建图、复核、被换掉的运行的用量(当前这次运行的在 run.usage),见 TurnUsage */ + usage?: TurnUsage /** * 助手问回来的那句话(N11):这一轮到此结束,问题作为这一轮的内容显示、进历史,输入框提示回答它;用户的回答就是下一轮。 * 以前这里没有分支:只问不改的一轮流结束时既没有 final 也没有 reply,这一轮一直停在「正在理解需求」 @@ -449,10 +477,58 @@ function buildMeta(t: ChatTurn): TurnMeta { asked: t.asked ? true : undefined, evidence: hasEvidence(t.output) || t.meta?.evidence || undefined, looks: lookList(t), + usage: usageOfTurn(t), at: Date.now(), } } +const USAGE_KEYS = ['cost_usd', 'unpriced_calls', 'calls', 'input_tokens', 'output_tokens'] as const + +/** 两份用量相加(缺的当 0)。b 不是对象时原样交回 a */ +export function addUsage(a: UsageTotal | undefined, b: UsageTotal | null | undefined): UsageTotal | undefined { + if (!b || typeof b !== 'object') return a + const out: UsageTotal = { ...(a ?? {}) } + for (const k of USAGE_KEYS) { + const v = Number(b[k] ?? 0) + if (Number.isFinite(v) && v) out[k] = Number(out[k] ?? 0) + v + } + if (out.cost_usd != null) out.cost_usd = Math.round(out.cost_usd * 1e6) / 1e6 + return out +} + +/** 运行的 usage(形状同 UsageTotal,可能带别的键)→ 只留要记的几项 */ +function usageTotal(u: Record | null | undefined): UsageTotal | undefined { + return u && typeof u === 'object' ? addUsage({}, u) : undefined +} + +/** 这一轮现在的用量:内存里累加的那几份,加上当前这次运行的(运行还没回来时沿用落库的那份) */ +export function usageOfTurn(t: ChatTurn): TurnUsage | undefined { + const base = t.usage ?? t.meta?.usage + const run = usageTotal(t.run?.usage) ?? base?.run + const out: TurnUsage = { ...(base ?? {}), ...(run ? { run } : {}) } + return Object.keys(out).length ? out : undefined +} + +/** 当前这次运行换下来了(自动重来、用户点重试):它的用量并进 earlier,这一轮的花费不丢这一笔 */ +function retireRun(t: ChatTurn): TurnUsage | undefined { + const u = usageOfTurn(t) + if (!u?.run) return u + const { run, ...rest } = u + return { ...rest, earlier: addUsage(rest.earlier, run) } +} + +/** + * 这一轮的花费:助手 + 运行 + 复核。一份都没有(老轮次、还没开始)是 null。unpriced 是估不出金额的调用次数: + * 有的话金额只是下限,界面写「≥」(lib/terms 的 runCostText) + */ +export function turnCost(u: TurnUsage | undefined): { usd: number; unpriced: number; calls: number } | null { + if (!u) return null + const parts = [u.copilot, u.review, u.earlier, u.run].filter(Boolean) as UsageTotal[] + if (!parts.length) return null + const sum = parts.reduce((acc, p) => addUsage(acc, p) ?? acc, {}) + return { usd: Number(sum.cost_usd ?? 0), unpriced: Number(sum.unpriced_calls ?? 0), calls: Number(sum.calls ?? 0) } +} + /** 这一轮的查看记录:操作流里有就取操作流的(重试会重新查看),恢复的历史轮次没有操作流,沿用 meta 里的 */ function lookList(t: ChatTurn): LookEvent[] | undefined { const looks = looksOf(t.ops) @@ -934,6 +1010,8 @@ export const useChat = create((set, get) => ({ runStatus: undefined, clipped: undefined, pendingRun: false, steps: undefined, hydrated: 'done', startedAt: Date.now(), endedAt: undefined, attempt: 0, cancel: null, noQuery: false, thinking: '', writing: null, scope: scope?.length ? scope : undefined, + // 上一次的运行换下来了,它花的钱还算在这一轮里 + usage: retireRun(t), })) void flow.persist({ status: 'running', error: '', answer: '' }) @@ -1246,9 +1324,23 @@ function historyOf(conversationId: string, upToTurnId: string): string { return lines.slice(-6).join('\n\n') } -/** 一轮最多自动再试一次。第二次还不行多半是问题本身没说清,该让用户介入 */ +/** + * 一轮最多自动再试一次。第二次还不行多半是问题本身没说清,该让用户介入。 + * 这几个决定(要不要运行、要不要重来、重来说什么)已经下沉到服务端 backend/app/chat/turn.py:final 带 next,复核带 + * retry_instruction,这里照它们走;下面这份常量和两种重来的措辞只在老服务端(没给这两个字段)时用,和服务端那份逐字 + * 对照(backend/tests/test_chat_turn_policy.py) + */ const MAX_ATTEMPTS = 2 +/** 重来时交给助手的话(同服务端 chat/turn.py 的 RETRY_WITH_BASE / RETRY_FROM_SCRATCH),只在老服务端时自己拼 */ +function retryInstruction(question: string, reason: string, hasBase: boolean): string { + return hasBase + ? `这个工作流上一次运行没有成功:${reason}。\n\n` + + `请针对这个原因改它(比如调大最大步数、改正工具参数、换个查询方式),` + + `改完继续回答原来的问题:${question}` + : `${question}\n\n(上一次没有成功:${reason}。请针对这个原因调整,重新给出完整的工作流。)` +} + interface PlanArgs { /** 用户原本问的是什么。跑图取数、复核都要用它,不能被重试的补充说明污染 */ question: string @@ -1298,26 +1390,25 @@ function plan(flow: Flow, args: PlanArgs) { * 这里会清空这一次的过程和答案——它是自动补救,用户还没拿到过答案。用户主动 * 点的重试走 retryTurn,上一次要留档。 */ - const retry = (reason: string) => { - if (attempt + 1 >= MAX_ATTEMPTS || !flow.alive()) return false + const retry = (reason: string, instruction?: string) => { + // 服务端给了那句话(复核的 retry_instruction)就是它已经按次数判过可以重来;老服务端由这里按次数判 + if ((!instruction && attempt + 1 >= MAX_ATTEMPTS) || !flow.alive()) return false const base = built && (built.nodes?.length ?? 0) > 0 ? built : null - patch(() => ({ + patch((t) => ({ attempt: attempt + 1, phase: 'planning', status: base ? '上次运行未成功,正在调整工作流…' : '上次运行未成功,正在重新生成工作流…', ops: [], events: [], run: null, output: null, final: undefined, runStatus: undefined, review: null, reviewRaw: null, rawOutput: null, lastSeq: 0, failure: null, error: '', + // 换下来的那次运行花的钱还是这一轮的 + usage: retireRun(t), })) plan(flow, { question, attempt: attempt + 1, baseGraph: base, scope, - instruction: base - ? `这个工作流上一次运行没有成功:${reason}。\n\n` - + `请针对这个原因改它(比如调大最大步数、改正工具参数、换个查询方式),` - + `改完继续回答原来的问题:${question}` - : `${question}\n\n(上一次没有成功:${reason}。请针对这个原因调整,重新给出完整的工作流。)`, + instruction: instruction ?? retryInstruction(question, reason, !!base), }) return true } @@ -1417,8 +1508,13 @@ function plan(flow: Flow, args: PlanArgs) { const blockers = ((op.issues ?? []) as ValidationIssue[]) .filter((i) => i.level === 'error') .map((i) => i.message) - if (blockers.length && !selfChecked && retry(`生成的工作流没有通过校验:${blockers.join(';')}`)) break - if (blockers.length) { + // 建完之后怎么走由服务端定(final.next,backend/app/chat/turn.py 的 next_step):run / ready / fail。 + // 老服务端没给 next:照原来的规则——有 error 级问题时自查过就判失败、没自查过重来一次;autorun=false 只建不跑 + const next: string = op.next === 'run' || op.next === 'ready' || op.next === 'fail' ? op.next + : blockers.length ? (selfChecked ? 'fail' : 'retry') + : op.autorun === false ? 'ready' : 'run' + if (next === 'retry' && retry(`生成的工作流没有通过校验:${blockers.join(';')}`)) break + if (next === 'fail' || next === 'retry') { // 自查修正过(或重来一次)还是没过。校验消息是写给画布用户的("先拖一个节点进来"), // 直接甩给一个在问数据页打字的人毫无意义——先给一句他能照做的, // 原文留在技术细节里作线索 @@ -1433,7 +1529,7 @@ function plan(flow: Flow, args: PlanArgs) { // 用户要的是流程本身时(「设计一个每天跑的工作流」),建完就跑 // 等于替他多花一次钱,而他要的是那张图 - if (op.autorun === false) { + if (next === 'ready') { // 问了用户的不自动运行(服务端 autorun 为假):图摆着等「运行」,问题照样作为这一轮的内容、进历史 patch(() => ({ graph, phase: 'ready', status: asked ? CHAT_BLUEPRINT_TEXT.asked : PHASE_TEXT.ready, cancel: null, @@ -1447,9 +1543,15 @@ function plan(flow: Flow, args: PlanArgs) { graph, phase: 'running', status: PHASE_TEXT.running, explanation: op.explanation ?? '', })) - void launch(flow, graph, question, retry) + void launch(flow, graph, question, retry, attempt) break } + case 'usage': + // 这一轮助手建图花了多少(服务端 answer_ops 最后一条):累加进这一轮的用量、随 meta 落库。结局(final、reply) + // 那一下已经落过库了,这里再写一次 meta + patch((t) => ({ usage: { ...(t.usage ?? t.meta?.usage), copilot: addUsage((t.usage ?? t.meta?.usage)?.copilot, op) } })) + void flow.persist() + break case 'error': // 后端给的是三段:message 人话、hint 怎么办、detail 原始异常。 // 原文不再截成一行甩给用户,收进可展开、可复制的技术细节 @@ -1498,7 +1600,8 @@ function plan(flow: Flow, args: PlanArgs) { } async function launch( - flow: Flow, graph: GraphSpec, question: string, retry?: (reason: string) => boolean, + flow: Flow, graph: GraphSpec, question: string, retry?: (reason: string, instruction?: string) => boolean, + attempt = 0, ) { const { patch } = flow try { @@ -1517,7 +1620,7 @@ async function launch( // 另开一页,它就成了「断在建图阶段」,放久了还会被当成断了写回 error。 // 「跑一下」发起时库里那行还是 done,一并改成 running void flow.persist({ run_id: run.id, status: 'running' }) - watch(flow, run.id, 0, question, retry) + watch(flow, run.id, 0, question, retry, attempt) } catch (e) { // 发起那一下没到后端:流程是好的,原样再发起就行。通用的「稍等几秒会自动重试」 // 在这里不成立——这一页没有谁会替它重发 @@ -1600,7 +1703,7 @@ function penOf(patch: Patch): { add: (e: RunEvent) => void; clear: () => void } */ function watch( flow: Flow, runId: string, after = 0, - question = '', retry?: (reason: string) => boolean, + question = '', retry?: (reason: string, instruction?: string) => boolean, attempt = 0, ) { const { patch, conversationId, turnId } = flow /** 这条流上已经见到结局事件了,stream.end 不用再判一次 */ @@ -1699,7 +1802,7 @@ function watch( patch(() => ({ status: '正在核对结果…', runStatus: 'succeeded' })) // 跑完不等于答对:先接住这次编排,确认没问题再交付 void settle(flow, runId, question, d.output ?? null, { - truncated: d.output_truncated === true, retry, + truncated: d.output_truncated === true, retry, attempt, }) break } @@ -1727,7 +1830,7 @@ function watch( if (status === 'succeeded') { // 结局事件在断线时丢了:成果以库里为准 ended = true - void settle(flow, runId, question, null, { retry }) + void settle(flow, runId, question, null, { retry, attempt }) return } // 失败、取消、或者运行不见了:状态和原因让 hydrate 去读 @@ -1754,7 +1857,11 @@ function watch( async function settle( flow: Flow, runId: string, question: string, eventOutput: Record | null, - opts: { truncated?: boolean; retry?: (reason: string) => boolean; run?: Run; endedAt?: number }, + opts: { + truncated?: boolean; retry?: (reason: string, instruction?: string) => boolean; run?: Run; endedAt?: number + /** 这一轮已经自动试了几次(从 0 数):交给复核,服务端据此决定给不给 retry_instruction */ + attempt?: number + }, ) { const { patch } = flow @@ -1781,7 +1888,7 @@ async function settle( // 复核慢到一定程度就不等了。它是补一层说明,不该反过来把答案扣住不放—— // 干净的运行后端 15ms 就返回,会走到这个上限的都是真叫了模型的那些 result = await Promise.race([ - api.copilot.review({ run_id: runId, question }), + api.copilot.review({ run_id: runId, question, attempt: opts.attempt ?? 0 }), new Promise((r) => setTimeout(() => r(null), REVIEW_TIMEOUT_MS)), ]) } catch { /* 复核用不了就按原样交付,下面照常走 */ } @@ -1796,8 +1903,21 @@ async function settle( // 事后排查"它当时为什么没警告我",靠的就是这个区别 const review = result && result.verdict !== 'ok' ? result : null - // 答案根本不可信,而且原因说得清楚——重建一次图再跑,别让用户自己发现 - if (review?.retry && review.severity === 'broken' && opts.retry) { + // 复核这一次的用量也是这一轮的花费(服务端 review_of_run 的 usage;老服务端没有) + if (result?.usage) { + const spent = result.usage + patch((t) => ({ usage: { ...(t.usage ?? t.meta?.usage), review: addUsage((t.usage ?? t.meta?.usage)?.review, spent) } })) + } + + // 答案根本不可信,而且原因说得清楚——重建一次图再跑,别让用户自己发现。要不要重来、重来说什么由服务端定(复核的 + // retry_instruction,backend/app/chat/turn.py):给了那句话就照它重来,给的是 null 就不重来。老服务端没有这个字段时 + // 照原来的规则自己判 + if (opts.retry && result && 'retry_instruction' in result) { + if (result.retry_instruction) { + const reason = review ? review.signals.map((s) => s.detail).join(';') || review.note : '' + if (opts.retry(reason, result.retry_instruction)) return + } + } else if (review?.retry && review.severity === 'broken' && opts.retry) { const reason = review.signals.map((s) => s.detail).join(';') || review.note if (opts.retry(reason)) return } diff --git a/frontend/src/types.ts b/frontend/src/types.ts index 0bd204f6..de58a5db 100644 --- a/frontend/src/types.ts +++ b/frontend/src/types.ts @@ -1699,6 +1699,17 @@ export interface ReviewResult { retry: boolean severity: 'broken' | 'degraded' | '' signals: ReviewSignal[] + /** + * 要不要带着原图重来一次、重来时交给助手的话(服务端 backend/app/chat/turn.py 按这一轮试过几次判):要就是那句话,不要 + * 是 null。老服务端没有这个字段,问数据页照原来的规则自己判 + */ + retry_instruction?: string | null + /** 复核这一次的用量(服务端 providers/usage.py 的汇总,没调模型时全 0):这一轮的花费 = 助手 + 运行 + 复核 */ + usage?: { + cost_usd?: number | null; unpriced_calls?: number; calls?: number; input_tokens?: number; output_tokens?: number + by_model?: Record + } } // ------------------------------------------------------------------------- diff --git a/scripts/check-chat.mjs b/scripts/check-chat.mjs index 8e1f91f2..029337e2 100644 --- a/scripts/check-chat.mjs +++ b/scripts/check-chat.mjs @@ -380,8 +380,10 @@ const TABLES = { const log = { patches: [], cancels: [], continues: [], runStarts: [], archived: [], posts: [], approvalGets: [], runGets: [], - deleted: [], gens: [], sourceGets: 0, catalogPatches: [], + deleted: [], gens: [], sourceGets: 0, catalogPatches: [], reviews: [], } +/** 新服务端复核给的重来那句话:前端得原样交回去,不自己拼 */ +const DECIDE_RETRY = '(服务端拼好的重来说法)照服务端的决定重新回答:有几家门店' const ctl = { slowMs: 0, failE: true, wsClosed: {}, approvals: [], thinkGo: false, writingGo: false, writingAt: 0, /** 列表只给前 8 个:筛选框刚好出现,删一个就不够 8 个了 */ @@ -495,6 +497,22 @@ async function fakeApi(route) { return route.fulfill({ status: 200, contentType: 'text/event-stream', body: ops.map((o) => `data: ${JSON.stringify(o)}\n\n`).join('') }) } + if (String(b.instruction ?? '').includes('照服务端的决定') || String(b.instruction ?? '').includes(DECIDE_RETRY)) { + // 新服务端:final 带 next(backend/app/chat/turn.py),最后一条是这一轮建图的用量(answer_ops 的 usage)。 + // 「只建不跑」那一问:autorun 没写 false,next 却是 ready——前端得照 next 走 + const ready = String(b.instruction ?? '').includes('只建不跑') + const ops = [ + { op: 'heartbeat', phase: 'planning', elapsed_ms: 300 }, + ...GRAPH.nodes.map((n) => ({ op: 'add_node', node: n })), + { op: 'done', explanation: '一张三步的图' }, + { op: 'check', status: 'passed', repaired: 0, warnings: [] }, + { op: 'final', graph: GRAPH, issues: [], explanation: '一张三步的图', autorun: true, next: ready ? 'ready' : 'run' }, + { op: 'usage', by_model: { m: { input_tokens: 4000, output_tokens: 300, calls: 1, cost_usd: 0.012, unpriced_calls: 0 } }, + input_tokens: 4000, output_tokens: 300, calls: 1, cost_usd: 0.012, unpriced_calls: 0 }, + ] + return route.fulfill({ status: 200, contentType: 'text/event-stream', + body: ops.map((o) => `data: ${JSON.stringify(o)}\n\n`).join('') }) + } if (String(b.instruction ?? '').includes('先问清楚')) { // 助手要先问清楚才能动手(服务端 copilot_gen 的 ask):问题转出去,这一轮到此为止——没有 final,也没有 reply const ops = [ @@ -553,6 +571,15 @@ async function fakeApi(route) { if (path === '/copilot/review' && method === 'POST') { const wait = ctl.reviewDelay[body().run_id] if (wait) await new Promise((r) => setTimeout(r, wait)) + if (String(body().run_id).startsWith('run-decide')) { + // 新服务端:第一次判不可用、给出重来的那句话;重来之后的那次没问题、不再重来。各带复核的用量 + log.reviews.push(body()) + const first = body().attempt === 0 + return json({ verdict: first ? 'annotated' : 'ok', note: first ? '查到一半就停了' : '', answer: null, retry: first, + severity: first ? 'broken' : '', signals: first ? [{ kind: 'step_limit', detail: '用满了步数', severity: 'broken' }] : [], + retry_instruction: first ? DECIDE_RETRY : null, + usage: { cost_usd: first ? 0.003 : 0, unpriced_calls: 0, calls: first ? 1 : 0 } }) + } // 老后端的复核不认 _evidence,照样回一次改写 if (body().run_id === 'run-evid' || body().run_id === 'run-evq') { return json({ verdict: 'rewritten', note: '检索降级过,结论请对照原始数据', answer: '改写后的答案:销售额大约四万多', @@ -584,6 +611,7 @@ async function fakeApi(route) { : conversation.includes('正在写') ? 'run-writing' : conversation.includes('强杀') ? 'run-killed' : conversation.includes('步数用满') ? `run-steps-${++runSeq}` + : conversation.includes('照服务端的决定') ? `run-decide-${++runSeq}` : `run-busy-${++runSeq}` log.runStarts.push({ id, graph: b.graph }) return json({ id, status: 'queued', run_class: 'exploratory', output: {}, usage: {} }) @@ -605,6 +633,10 @@ async function fakeApi(route) { if (id.startsWith('run-404')) return json({ detail: '运行不存在' }, 404) if (RUNS[id]) return json({ id, run_class: 'exploratory', usage: {}, ...RUNS[id] }) if (id.startsWith('run-c') || id === 'run-b1') return json({ id, status: 'succeeded', run_class: 'exploratory', output: {}, usage: {} }) + if (id.startsWith('run-decide')) { + return json({ id, status: 'succeeded', run_class: 'exploratory', output: { answer: '三家门店。' }, + usage: { cost_usd: 0.02, calls: 2, input_tokens: 6000, output_tokens: 400 } }) + } return json({ id, status: 'interrupted', run_class: 'exploratory', output: {}, usage: {} }) } if (path.startsWith('/approvals')) { @@ -773,6 +805,17 @@ function script(runId, after = 0) { end: null, } } + if (runId.startsWith('run-decide')) { + return { + events: [ + ev(1, 'run.started', null, { nodes: 3 }), + ev(2, 'node.started', 'ag', {}), + ev(3, 'node.finished', 'ag', { duration_ms: 900 }), + ev(4, 'run.finished', null, { output: { answer: '三家门店。' } }), + ], + end: 'succeeded', + } + } if (runId.startsWith('run-steps')) { return { events: [ @@ -1546,6 +1589,45 @@ for (const theme of THEMES) { await ctx.close() }) + await section('decide', '新服务端:照 final.next 和复核的 retry_instruction 走,这一轮的花费 = 助手 + 运行 + 复核', async () => { + const { page, ctx, errors } = await open(theme) + await goto(page, 'c0emptg') + const gens = log.gens.length + const runs = log.runStarts.length + const reviews = log.reviews.length + await send(page, '照服务端的决定:有几家门店') + const done = await page.waitForFunction(() => { + const t = window.__chat.getState().byConversation.c0emptg?.at(-1) + return t?.phase === 'done' && t?.run?.id?.startsWith('run-decide') + }, null, { timeout: 8000 }).then(() => true, () => false) + await page.waitForTimeout(500) + const turn = (await chatState(page)).byConversation.c0emptg.at(-1) + check('复核判不可用:带着原图重来一次', done && log.gens.length - gens === 2 && log.runStarts.length - runs === 2, + `${log.gens.length - gens} 次生成、${log.runStarts.length - runs} 次运行`) + check('重来时交回去的就是服务端给的那句话', log.gens.at(-1)?.instruction === DECIDE_RETRY, log.gens.at(-1)?.instruction) + check('第二次复核带着这一轮试过的次数', log.reviews.slice(reviews).map((r) => r.attempt).join(',') === '0,1', + JSON.stringify(log.reviews.slice(reviews))) + const last = log.patches.filter((x) => x.body?.meta?.usage).at(-1)?.body?.meta?.usage + check('meta.usage 记下助手、复核、换下来的运行和这一次运行', !!last && Math.abs(last.copilot?.cost_usd - 0.024) < 1e-9 + && Math.abs(last.review?.cost_usd - 0.003) < 1e-9 && Math.abs(last.earlier?.cost_usd - 0.02) < 1e-9 + && Math.abs(last.run?.cost_usd - 0.02) < 1e-9, JSON.stringify(last)) + const tag = page.locator(`[data-turn="${turn.id}"] [data-turn-cost]`) + const tagText = await tag.innerText().catch(() => '') + const title = await tag.getAttribute('title').catch(() => '') + check('头部写这一轮的花费,悬停分得清助手、运行、复核', tagText.includes('$0.067') && (title ?? '').includes('助手建图') + && (title ?? '').includes('复核'), `${tagText} | ${title}`) + + // 只建不跑:autorun 没写 false,next 是 ready,前端照 next 走、不发起运行 + const before = log.runStarts.length + await send(page, '照服务端的决定,只建不跑') + const ready = await page.waitForFunction(() => window.__chat.getState().byConversation.c0emptg?.at(-1)?.phase === 'ready', + null, { timeout: 6000 }).then(() => true, () => false) + await page.waitForTimeout(300) + check('next=ready:图摆着等运行,不发起', ready && log.runStarts.length === before, `${log.runStarts.length - before} 次运行`) + check('没有运行时报错', errors.length === 0, errors[0] ?? '') + await ctx.close() + }) + await section('makeapp', '做成应用:带着这次运行进蓝图,不再跳画布发布', async () => { const { page, ctx, errors } = await open(theme) const made = []