assistant-turn.ts 70 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603
  1. import { FileCard, Message } from './api/models';
  2. import { GroupTurn } from './group-turns';
  3. import { mergeConsecutiveBodies, MergedMessage } from './message-merge';
  4. import {
  5. isCommandLine,
  6. isProseLine,
  7. isToolActivityMessage,
  8. ProcessStep,
  9. splitMessage,
  10. } from './message-segments';
  11. import { fmtTime } from './time';
  12. import { Turn } from './turn-aggregator';
  13. /**
  14. * AI 输出的回合视图模型(2026-11-06 用户需求)
  15. *
  16. * ## 为什么要有这一层
  17. *
  18. * 用户要求「所有输出在一个固定区域内持续追加,顶部过程区可折叠,
  19. * 下半部分是正文与文档宫格」,并且**双端、单聊与群聊效果一致**。
  20. *
  21. * 但四个页面原本各写一套:桌面单聊是扁平流、桌面群聊是 turn → 容器块、
  22. * 移动两页又是一套。规则一旦分叉就会漂移(右栏预览就是前车之鉴)。
  23. *
  24. * 所以把「回合长什么样」收敛到这里:**纯函数,不依赖 Angular**,
  25. * 两端共用同一份数据,只在渲染层保留与端相关的样式差异。
  26. *
  27. * ## 单聊与群聊的统一
  28. *
  29. * - 群聊:一个回合有 N 个块(每个被 @ 的容器一块)
  30. * - 单聊:同样用块表达,但**固定只有 1 块**(`agentId: null`)
  31. *
  32. * 这样上层模板只认 `blocks[]`,不必区分单聊群聊。
  33. *
  34. * ## 顶部过程区从哪来
  35. *
  36. * 容器的回复把「过程行」和「正文」混在**同一条消息文本**里:
  37. *
  38. * ```
  39. * 我先看一下环境。
  40. * · bash
  41. * 找到了,正在改。
  42. * ```
  43. *
  44. * 两步取过程:
  45. * ① 纯终端消息(整条都是 `· bash` 这类)→ 整条进过程区
  46. * ② 混在正文里的过程行 → 由 `splitMessage` 拆出来
  47. *
  48. * 判定全部复用 `message-segments.ts` 的既有口径,**不在本文件新造正则**。
  49. */
  50. /** 下半区的内容块(顶部过程区已单独抽出,不在此列) */
  51. export type TurnBodyBlock =
  52. | { kind: 'text'; key: string; message: MergedMessage }
  53. | { kind: 'file'; key: string; file: FileCard; message: Message }
  54. | { kind: 'task'; key: string; taskId: string; message: Message };
  55. /** 一个「说话方」在回合内的呈现数据 */
  56. export interface TurnBlockView {
  57. key: string;
  58. /** 单聊为 null;群聊为容器 id */
  59. agentId: string | null;
  60. /** 群聊成员显示名(由宿主传入 `nameOf` 时才有) */
  61. agentName?: string;
  62. /**
  63. * 容器真实处理耗时(秒):首条 → 末条 agent 消息。
  64. *
  65. * 🔴 UI **不再直接读取**它(读数走 `elapsedSeconds()`),仅保留作数据/诊断用,
  66. * 以及 `updatedAt <= startAt` 这种退化情形下的兜底。
  67. */
  68. seconds: number;
  69. /**
  70. * 本块开始时刻(epoch ms;0 = 无锚点)。
  71. *
  72. * 2026-11-10 新增:秒数改为**逐秒现算**,锚点必须是时刻而不是秒数,
  73. * 否则只能靠容器发新事件来「跳一下」。见 `elapsedSeconds()`。
  74. */
  75. startAt: number;
  76. /** 本块最后活动时刻(epoch ms,0 = 无消息)—— 结束态定格用 */
  77. updatedAt: number;
  78. /** 顶部过程区 */
  79. steps: ProcessStep[];
  80. /** 下半区正文 / 文件 / 任务 */
  81. body: TurnBodyBlock[];
  82. /** 文件宫格的数据(从 body 的 file 项抽出,便于模板直接栅格渲染) */
  83. files: { key: string; file: FileCard }[];
  84. /** 本块是否仍在输出 */
  85. live: boolean;
  86. /**
  87. * 容器是否**明确宣告本轮结束**(2026-11-11)。
  88. *
  89. * 为 true 时 `live` 必定为 false —— 结束信号优先于所有静默窗口。
  90. * 渲染层可据此把「已完成」写得更肯定(可选,不影响原有判据)。
  91. */
  92. turnEnded?: boolean;
  93. /**
  94. * 是否仍在**等第一口气**(2026-11-11)。
  95. *
  96. * 与 `live` 解耦:`live` 受 25 秒静默窗口约束会提前转 false,
  97. * 而用户要一直等到 180 秒超时才该失去等待指示。
  98. * 渲染层应把 `live || waiting` 当作「还在进行中」。
  99. */
  100. waiting: boolean;
  101. /** 本块是否无内容且未在输出(群聊未响应) */
  102. empty: boolean;
  103. /**
  104. * 本块自身合并后的正文(2026-11-07)。
  105. *
  106. * 群聊多容器时,**每个容器单独渲染自己的正文**,不能跨容器拼接 ——
  107. * 用户要求「@ 了三个人就要看出谁说了什么」,拼在一起等于丢失归属。
  108. * 单聊只有一块,用回合级的 `merged` 即可。
  109. */
  110. merged: TurnMergedBody | null;
  111. /** 用户发出这条消息的时刻(毫秒)。0 = 无锚点(容器主动发言) */
  112. waitingSince: number;
  113. /**
  114. * 构建这一帧时,距用户发消息已经等了多久(毫秒)。
  115. *
  116. * 🔴 组件渲染用 `waitingSince` + 实时时钟现算,`waitMs` 只是构建快照,
  117. * 供纯函数与测试使用(2026-11-09)。
  118. */
  119. waitMs: number;
  120. }
  121. export type TurnPhase = 'thinking' | 'replying' | 'done' | 'failed' | 'idle' | 'progressOnly';
  122. /**
  123. * 整轮合并后的正文(2026-11-07 用户需求)。
  124. *
  125. * 用户要求「这一轮对话的所有输出融合到**一张卡片**里,不再是每段单独复制,
  126. * 顶部折叠思考和操作」。所以正文本不该按容器/消息分段,而应拼成一份。
  127. */
  128. export interface TurnMergedBody {
  129. /** 稳定 key(首条正文消息 id),用于模板 track */
  130. key: string;
  131. /** 合并后的正文(Markdown) */
  132. text: string;
  133. /** 参与合并的消息(末尾那条用于取时间戳、任务引用等元信息) */
  134. message: Message;
  135. }
  136. /** 一个完整回合:一条用户消息 + 它的全部回复 */
  137. export interface AssistantTurn {
  138. id: string;
  139. userMessage?: Message;
  140. /**
  141. * 本回合里**早于 `userMessage`** 的提问(2026-11-11)。
  142. *
  143. * 用户连发多条时并入同一回合:`userMessage` 是最新那条,
  144. * 前面几条按时间顺序放这里。渲染层要先展示它们,用户才看得到自己说过什么。
  145. */
  146. priorAsks?: Message[];
  147. /** 用户在同回合内额外发的文件(群聊「文字 + 多个文件」时) */
  148. userFiles: Message[];
  149. blocks: TurnBlockView[];
  150. phase: TurnPhase;
  151. /** 容器真实处理耗时(秒,诊断用;UI 读数走 `elapsedSeconds(blocks[i], now)`) */
  152. seconds: number;
  153. live: boolean;
  154. closed: boolean;
  155. /** 过程步骤总数,用于折叠头「运行了 N 步」 */
  156. stepCount: number;
  157. /** 文件总数,用于宫格标题 */
  158. fileCount: number;
  159. /**
  160. * 正文里声明了、但**没有拿到对应附件事件**的文件数(2026-11-16)。
  161. *
  162. * ## 为什么需要
  163. *
  164. * 容器发文件的机制(2026-11-16 向 `agent-node-lj-test` 核实,容器原话):
  165. * 「我在正文里写 `MEDIA:/绝对路径`,由 Matrix 适配器解析后以 m.file 附件事件发出,
  166. * 同时正文保留文本。」
  167. *
  168. * 正常情况下「几个 MEDIA 标记 = 几个 m.file 事件」。但容器也承认会出现:
  169. * 「标记存在但适配器没有为它们生成对应的事件……实际只到了部分文件」。
  170. *
  171. * 这时用户在正文里看得见 3 个链接,卡片区却只有 2 张,**没有任何提示**——
  172. * 看起来像 App 吞了一个文件。
  173. *
  174. * 容器的建议原话:
  175. * 「最可靠的是数附件事件,而不是数正文链接……两者不一致就按『缺卡片』处理。」
  176. *
  177. * 所以这里只做**对账提示**,不伪造卡片:正文里数到 N 个,附件事件只有 M 个,
  178. * 差多少就告诉用户多少。真正的补齐在容器侧(适配器要为每个标记生成事件)。
  179. *
  180. * 只统计**明确的 MEDIA 标记**与**可识别的附件链接**,不做模糊猜测 ——
  181. * 正文里随便一句 URL 不该被当成「文件丢失」。
  182. */
  183. missingFileCount: number;
  184. /**
  185. * 整轮合并后的正文与文件(2026-11-07)。
  186. *
  187. * 「一整轮 = 一张卡」:不管中间隔了多少次工具调用,正文全部拼成一份
  188. * 给卡片渲染,过程进顶部折叠区,文件进底部宫格。
  189. *
  190. * 🔴 **单聊用这个**。群聊多容器时各自独立,见 `blocks[].merged`。
  191. */
  192. merged: TurnMergedBody | null;
  193. /** 整轮的全部文件(跨容器聚合,宫格统一渲染) */
  194. files: { key: string; file: FileCard }[];
  195. }
  196. /** 构建一块所需的原料(由单聊/群聊两种输入各转一份) */
  197. interface BlockSource {
  198. agentId: string | null;
  199. /**
  200. * 显式块 key(2026-11-11)。
  201. *
  202. * 单聊按轮次拆块后,每块 `agentId` 都是 null,若仍用 `agentId ?? 'agent'`
  203. * 生成 key,多块就会**全部叫 'agent'** → 模板 `@for track` 报 NG0955,
  204. * 且 `segTime`/`waitLabels`/`targetsOf` 以 key 为字典键,后一轮覆盖前一轮,
  205. * 读数在 39s / 9s / 43s 之间乱跳(用户实测)。
  206. *
  207. * 拆轮时由调用方传 `agent:<首条消息 id>`;不传则回落到旧逻辑。
  208. */
  209. key?: string;
  210. messages: Message[];
  211. startedAt: number;
  212. updatedAt: number;
  213. typing: boolean;
  214. closed: boolean;
  215. /**
  216. * 容器**明确宣告本轮结束**(2026-11-11)。
  217. *
  218. * 来源:容器在 `post_llm_call` 发 `m.typing=false`,App 侧
  219. * `chat.service` 记录该事件的时刻,再按「是否晚于本块末条消息」判定。
  220. *
  221. * 语义与 `!typing` 不同:`typing=false` 只是「此刻没在打字」,
  222. * 两条消息之间的空档也会出现;本字段要求信号**确实在本轮末条消息之后**,
  223. * 才算「这一轮干完了」。
  224. */
  225. turnEnded?: boolean;
  226. }
  227. /* ------------------------------------------------------------------ */
  228. /* 从原始消息派生「过程」与「正文」 */
  229. /* ------------------------------------------------------------------ */
  230. /**
  231. * 把一组消息拆成「顶部过程步骤」与「下半区内容块」。
  232. *
  233. * 处理顺序很关键:
  234. * 1. 先按纯终端消息把整条消息**提走**进过程区(它不该出现在正文里)
  235. * 2. 剩下的正文消息交给 `mergeConsecutiveBodies` 合并连续片段
  236. * 3. 合并后再用 `splitMessage` 把夹在正文里的过程行拆出来
  237. *
  238. * 🔴 这里不能只认 `block.kind === 'process'`。
  239. * `toBlocks()` 有个既有设计:**孤立单步(前后无空行)会被内联成 text**
  240. * (`message-segments.ts:281-285`),为的是「只有一个步骤时不必多点一次」。
  241. * 但在本视图模型里,顶部过程区与下半区必须**严格互斥**,否则
  242. * 「过程区折叠了、正文里却还留着那一行」。
  243. * 所以这里按**行**再判一次:`· 工具名` 形态的行一律归过程区。
  244. */
  245. function splitIntoParts(messages: Message[]): {
  246. steps: ProcessStep[];
  247. body: TurnBodyBlock[];
  248. } {
  249. const steps: ProcessStep[] = [];
  250. const bodies: Message[] = [];
  251. /**
  252. * 容器声明为 `final` 的消息 id(2026-11-11)。
  253. *
  254. * 这些消息在 ② 步**不能再被 `divideText` 拆一次** —— 容器已经明确说
  255. * 「整条是正文」,正文里出现 `cd /opt/...` 这类行也不该被当成命令挪进过程区。
  256. */
  257. const forcedFinal = new Set<string>();
  258. for (const m of messages) {
  259. const text = m.text ?? '';
  260. if (!text.trim()) continue;
  261. /*
  262. * 🔴 一律按行拆分,不再「整条判成工具活动就丢弃」(2026-11-11 修复)。
  263. *
  264. * 原实现:
  265. * if (isToolActivityMessage(text) && !proseOf(text)) {
  266. * steps.push(...stepsOf(text)); // stepsOf 只取 process 块
  267. * continue; // ← 同条消息里的正文永远消失
  268. * }
  269. *
  270. * 后果(用户实测):容器回一段混排消息,比如
  271. * 「有的,共 69 行…」 + `**已上云(可直接下载)**` + 两行 `🐍 Running code…`
  272. * 工具行严格过半 → 整条进过程区 → 那句结论和文件名**再也看不到**。
  273. *
  274. * 现在交给 `divideText` 逐行判:工具行 / 命令行进过程区,
  275. * 其余(含结论、markdown 加粗、列表)留在正文。
  276. */
  277. /*
  278. * 🔴 容器声明了类别就**完全听它的**(2026-11-11)。
  279. *
  280. * 这是根治「日志吞正文」的路径:文本启发式永远有误判(正文里出现代码块、
  281. * 命令行、英文列表都可能被当成过程)。容器自己知道哪条是过程、哪条是结论。
  282. *
  283. * 容器改造完成前该字段缺失 → 自动落回下面的启发式,行为不变。
  284. */
  285. if (m.fmodeKind === 'process') {
  286. /* 整条进过程区:不再逐行猜,避免把里面的中文切成「正文」 */
  287. for (const line of text.split('\n')) {
  288. const t = line.trim();
  289. if (t) steps.push({ kind: 'tool', label: t });
  290. }
  291. continue;
  292. }
  293. if (m.fmodeKind === 'final') {
  294. /* 整条是正文:即使里面看起来像命令行,也不拆(②' 步会跳过它) */
  295. bodies.push(m);
  296. forcedFinal.add(m.id);
  297. continue;
  298. }
  299. const { steps: s, text: kept } = divideText(text);
  300. steps.push(...s);
  301. if (kept.trim()) bodies.push(kept.trim() === text.trim() ? m : { ...m, text: kept.trim() });
  302. }
  303. /*
  304. * ② 合并连续正文。
  305. * 带附件的消息由 `mergeConsecutiveBodies` 内部规则挡住(见 message-merge.ts 注释),
  306. * 它们不进 `bodies`,单独成块。
  307. */
  308. const merged = mergeConsecutiveBodies(bodies);
  309. const body: TurnBodyBlock[] = [];
  310. for (const mm of merged) {
  311. /*
  312. * 容器声明为 final 的正文**不做二次拆分**(2026-11-11)。
  313. * 合并后仍按 `mergedIds` 判断:只要**所有**参与合并的消息都是 final,
  314. * 整段就当正文;否则走启发式(混合情况下以启发式为准更安全)。
  315. */
  316. const allFinal = mm.mergedIds.length > 0 && mm.mergedIds.every((id) => forcedFinal.has(id));
  317. if (allFinal) {
  318. if ((mm.text ?? '').trim()) {
  319. body.push({ kind: 'text', key: mm.mergedIds[0], message: { ...mm, text: (mm.text ?? '').trim() } });
  320. }
  321. if (mm.file) body.push({ kind: 'file', key: `${mm.mergedIds[0]}-f`, file: mm.file, message: mm });
  322. if (mm.taskId) body.push({ kind: 'task', key: `${mm.mergedIds[0]}-t`, taskId: mm.taskId, message: mm });
  323. continue;
  324. }
  325. const { steps: s, text } = divideText(mm.text ?? '');
  326. steps.push(...s);
  327. if (text.trim()) {
  328. body.push({ kind: 'text', key: mm.mergedIds[0], message: { ...mm, text: text.trim() } });
  329. }
  330. if (mm.file) {
  331. body.push({ kind: 'file', key: `${mm.mergedIds[0]}-f`, file: mm.file, message: mm });
  332. }
  333. if (mm.taskId) {
  334. body.push({ kind: 'task', key: `${mm.mergedIds[0]}-t`, taskId: mm.taskId, message: mm });
  335. }
  336. }
  337. /*
  338. * ③ 只有附件、没有正文的消息不会被 `mergeConsecutiveBodies` 输出(它只处理 text),
  339. * 这里补回来,否则「容器只回了一个文件」会整个消失。
  340. */
  341. for (const m of messages) {
  342. if (!m.file && !m.taskId) continue;
  343. const covered = body.some((b) => b.message.id === m.id);
  344. if (covered) continue;
  345. if (m.file) body.push({ kind: 'file', key: `${m.id}-f`, file: m.file, message: m });
  346. if (m.taskId) body.push({ kind: 'task', key: `${m.id}-t`, taskId: m.taskId, message: m });
  347. }
  348. return { steps, body };
  349. }
  350. /**
  351. * 从一段文本里取过程行(返回 steps)。
  352. * 纯终端文本直接用 `splitMessage` 的 process 块。
  353. */
  354. function stepsOf(text: string): ProcessStep[] {
  355. const out: ProcessStep[] = [];
  356. for (const b of splitMessage(text)) {
  357. if (b.kind === 'process') out.push(...b.steps);
  358. }
  359. return out;
  360. }
  361. /**
  362. * 把一段**混合**文本拆成「过程步骤」与「纯正文」。
  363. *
  364. * 两步:
  365. * ① `splitMessage` 能识别的 process 块 → 步骤
  366. * ② 剩下的 text 块里,仍可能有被 `toBlocks` 内联的单步行(`· bash`),按行再剥一次
  367. *
  368. * 返回的 text 已不含过程行,顶部折叠后正文不会再出现一遍。
  369. */function divideText(text: string): { steps: ProcessStep[]; text: string } {
  370. const steps: ProcessStep[] = [];
  371. const keep: string[] = [];
  372. /*
  373. * 🔴 先按代码围栏切段,再在段内逐行拆(2026-11-11 修复空代码块)。
  374. *
  375. * 原来直接对整条文本逐行判:闭合围栏 ``` 被 `isCommandLine` 当成命令
  376. * 挪进过程区,正文里只剩开围栏 → markdown 解析出一个**空 `<pre>`**,
  377. * 叠加 `md-render` 的「复制」按钮,界面上就是一个黑色空块。
  378. *
  379. * 现在围栏内的所有行**原样进正文**,不参与任何命令行/步骤判定。
  380. */
  381. for (const piece of splitByFences(text)) {
  382. if (piece.fence) {
  383. keep.push(...piece.lines);
  384. continue;
  385. }
  386. for (const b of splitMessage(piece.lines.join('\n'))) {
  387. if (b.kind === 'process') {
  388. /*
  389. * 🔴 `splitMessage` 也会把「行首 emoji + 成句中文」解析成 process 块
  390. * (`💾 自我升级小结:…了。` 实测如此)。这类是**结论**不是过程,
  391. * 交还正文,否则折叠区里会出现半句话。
  392. */
  393. const prose = b.steps.filter((s) => isProseLine(s.label));
  394. const tools = b.steps.filter((s) => !isProseLine(s.label));
  395. steps.push(...tools);
  396. for (const p of prose) keep.push(p.label);
  397. continue;
  398. }
  399. if (b.kind !== 'text') continue;
  400. for (const line of b.text.split('\n')) {
  401. const inline = inlineStepOf(line);
  402. if (inline && !isProseLine(line)) {
  403. steps.push(inline);
  404. continue;
  405. }
  406. /*
  407. * 裸命令行(无 emoji、无 `·` 前缀)也要进过程区(2026-11-11)。
  408. * 容器会把 `cd /opt/data && node x.js` 直接贴出来 ——
  409. * 它既不是正文也不带工具标记,光靠 `inlineStepOf` 识别不到。
  410. */
  411. if (isCommandLine(line)) {
  412. steps.push({ kind: 'tool', label: line.trim() });
  413. continue;
  414. }
  415. keep.push(line);
  416. }
  417. }
  418. }
  419. return { steps, text: keep.join('\n').replace(/\n{3,}/g, '\n\n') };
  420. }
  421. /**
  422. * 按**成对**代码围栏切成若干段(2026-11-11)。
  423. *
  424. * - 围栏行本身与其内部内容 → `fence: true` 段,调用方应整段当正文
  425. * - 围栏外 → `fence: false` 段,调用方可继续逐行拆
  426. * - **未闭合**的围栏延续到文末,整段当正文(宁可多显示代码,不要吞内容)
  427. */
  428. function splitByFences(text: string): { fence: boolean; lines: string[] }[] {
  429. const FENCE = /^\s*(`{3,}|~{3,})/;
  430. const out: { fence: boolean; lines: string[] }[] = [];
  431. let cur: { fence: boolean; lines: string[] } = { fence: false, lines: [] };
  432. let open: string | null = null;
  433. const flush = (): void => {
  434. if (cur.lines.length > 0) out.push(cur);
  435. };
  436. for (const line of text.split('\n')) {
  437. const fm = FENCE.exec(line);
  438. if (fm) {
  439. const mark = fm[1][0];
  440. if (open === null) {
  441. /* 开围栏:把围栏行放进一个新的 fence 段 */
  442. flush();
  443. cur = { fence: true, lines: [line] };
  444. open = mark;
  445. } else if (mark === open) {
  446. /* 闭围栏:收尾当前 fence 段 */
  447. cur.lines.push(line);
  448. flush();
  449. cur = { fence: false, lines: [] };
  450. open = null;
  451. } else {
  452. /* 围栏内出现另一种记号 → 当内容 */
  453. cur.lines.push(line);
  454. }
  455. continue;
  456. }
  457. cur.lines.push(line);
  458. }
  459. flush();
  460. return out;
  461. }
  462. /** 行首 `· 工具名` 形态 → 一步;否则 null */
  463. const INLINE_STEP = /^\s*[·•]\s*([a-zA-Z][\w.\-]{0,40})(?:\s*[::]?\s*(.+))?$/;
  464. function inlineStepOf(line: string): ProcessStep | null {
  465. const m = INLINE_STEP.exec(line);
  466. if (!m) return null;
  467. return { kind: 'tool', label: m[1], detail: m[2]?.trim() || undefined };
  468. }
  469. /**
  470. * 这条「看起来像终端活动」的文本,其实是一句**结论性叙述**吗?
  471. *
  472. * ## 为什么需要(2026-11-07 实测)
  473. *
  474. * 容器会这样汇报一次自我升级:
  475. *
  476. * ```
  477. * 💾 自我升级小结:🔧 「multi-artifact-delivery」磨得更锋利了。
  478. * ```
  479. *
  480. * 行首 `💾` 命中了 `TOOL_EMOJI_LEAD`,于是整条被当成工具活动,
  481. * 折叠头上显示成「运行了 1 步 · 自我升级小结:…」——
  482. * 用户要读的**结论**被折进了过程区。
  483. *
  484. * ## 判定口径(宁可放过、不可误折)
  485. *
  486. * 同时满足才算叙述:
  487. * ① 以中文句末标点收尾(。!?)
  488. * ② 去掉行首 emoji 后,剩下的是一段**中文句子**(至少 6 个汉字)
  489. *
  490. * 真正的工具行(`💻 bash`、`✍️ Writing /path`)主体是英文工具名与路径,
  491. * 不含成句中文,不会被误判。
  492. */
  493. function proseOf(text: string): boolean {
  494. const lines = text.split(/\r?\n/).map((l) => l.trim()).filter(Boolean);
  495. if (lines.length === 0) return false;
  496. // 只要有一条是「成句中文」,整条就当正文 —— 终端活动不会夹杂叙述
  497. return lines.some((line) => {
  498. if (!/[。!?]$/.test(line)) return false;
  499. // 剥掉行首的项目符号与 emoji(含变体选择符 / 零宽连接符)
  500. const body = line
  501. .replace(/^[\s*·•-]+/, '')
  502. .replace(/^[\p{Extended_Pictographic}️‍\u{1F3FB}-\u{1F3FF}]+\s*/u, '');
  503. return (body.match(/[一-龥]/g)?.length ?? 0) >= 6;
  504. });
  505. }
  506. /* ------------------------------------------------------------------ */
  507. /* 块 → 视图 */
  508. /* ------------------------------------------------------------------ */
  509. /**
  510. * 默认「还在输出」的静默窗口 —— 与 `turn-aggregator.QUIET_MS` 同源。
  511. *
  512. * 🔴 为什么不能用一个短窗口(2026-11-08 用户反馈「只闪一下『正在回复』就消失」):
  513. * 容器跑工具时,两段正文之间常有 5–20 秒空档。窗口短于一拍,
  514. * 回合就被判成「已结束」,界面的「正在思考…」随之消失 ——
  515. * 而容器其实还在干活,用户无从得知。
  516. *
  517. * 调用方应优先传 `QUIET_MS`;这里的字面量只是兜底,两处必须同步修改。
  518. */
  519. /**
  520. * 判定「超时」的时长门槛。
  521. *
  522. * ## 演进
  523. *
  524. * | 时间 | 值 | 原因 |
  525. * |---|---|---|
  526. * | 2026-11-10 | 5 分钟 | 初值 |
  527. * | 2026-11-10 | 3 分钟 | 5 分钟太长(干等),1 分钟太短(误报)→ 折中 |
  528. * | **2026-11-11** | **5 分钟** | 见下(**语义变了,不能直接沿用旧结论**) |
  529. *
  530. * ## 为什么又回到 5 分钟
  531. *
  532. * 旧结论「5 分钟太长」成立的前提是:**超时会强行把界面改成「已结束」**,
  533. * 用户干等 5 分钟看到的是错误的完成状态,所以越短越好。
  534. *
  535. * 2026-11-11 用户裁决「应该保持到会话结束」之后,这个前提没了:
  536. * · 超时**不再改写状态** —— 长任务跑多久就如实显示多久「输出中」
  537. * · 超时只决定**什么时候弹一条提示**,告诉用户「好像有点久」
  538. *
  539. * 在这种情况下,短反而有害:
  540. * · 容器自己实测跑过 3 分钟以上(它还说过「3 分钟了,值得等」)
  541. * · 180 秒会在正常长任务上频繁误报,把提示变成狼来了
  542. *
  543. * 5 分钟能覆盖实测到的长任务,同时容器真挂了也不会让用户无限茫然。
  544. *
  545. * @see isTurnStalled —— 另一条提示路径:**有输出但长时间无新增**,
  546. * 门槛是 `STALL_MS`(60 秒),与这里互补,不会重复打扰。
  547. */
  548. export const TURN_TIMEOUT_MS = 300_000;
  549. const DEFAULT_QUIET_MS = 25_000;
  550. /**
  551. * 「卡住」门槛:**最后一条输出之后**静止多久算异常。
  552. *
  553. * 取 60 秒:容器跑一轮工具调用常有 10~30 秒空档,
  554. * 1 分钟毫无动静基本可以认定停下了,同时不至于误报。
  555. *
  556. * 🔴 位置必须在 `toBlockView` **之前**:它用这个常量做「长任务宽限」,
  557. * 而模块级 `const` 是从上往下求值的,放到后面会触发 TDZ 报错。
  558. */
  559. export const STALL_MS = 60_000;
  560. function toBlockView(
  561. src: BlockSource,
  562. now: number,
  563. quietMs: number,
  564. waitingSince = 0,
  565. /**
  566. * 用户已发出消息、但容器还一条都没回(2026-11-09)。
  567. *
  568. * 🔴 为什么需要独立标志:
  569. * 这类回合 `blocks` 为空 → `updatedAt = 0` → `idleFor` 极大 → `live` 恒 false,
  570. * 于是回合卡根本不会生成,界面在发送后**什么状态都不显示**,
  571. * 只能干等容器约 10 秒后第一次回话(用户实测「10 秒后才显示正在思考」)。
  572. *
  573. * 但「已发出」本身就是一个确定的状态,应该立刻可见。
  574. */
  575. awaitingFirstReply = false,
  576. /**
  577. * 容器**明确**上报的本会话空闲态(2026-11-11)。
  578. *
  579. * 三态:`true` 明确空闲 → 直接收尾(与 ✅ reaction 同级的事实信号);
  580. * `false` 明确在跑;`undefined` 不知道 → 不参与判定。
  581. *
  582. * 用户实测:右上角已显示「在线」(容器报 idle),卡片却还挂着「50s 输出中」。
  583. * 根因就是这里只把 `quietMs` 置 0,而「有步骤 + 无信号」的保持逻辑不看它。
  584. */
  585. agentIdle: boolean | undefined = undefined,
  586. ) : TurnBlockView {
  587. const { steps, body } = splitIntoParts(src.messages);
  588. /*
  589. * 🔴 同一文件只出一张卡(2026-11-14 用户截图实证)。
  590. *
  591. * 现象:容器回复一张 HTML 表格,界面上出现**两个同名卡片**。
  592. * 根因:同一个文件在时间线里有两条消息各带一次 `m.file`
  593. * (一条是插件转发的原始附件,一条是 Agent 回复里附带的那份),
  594. * 而这里直接 map 出去、不做任何去重。
  595. *
  596. * 判据用附件 URL(同一个 s3 对象地址必然相同),退化时用文件名+大小。
  597. * 保留**先出现**的那条 —— key 更稳定,也与用户阅读顺序一致。
  598. */
  599. const seenFiles = new Set<string>();
  600. const files = body
  601. .filter((b): b is Extract<TurnBodyBlock, { kind: 'file' }> => b.kind === 'file')
  602. .filter((b) => {
  603. const f = b.file;
  604. /* 优先用云盘地址(同一对象必然相同);退化用 url;再退化用 名字+大小 */
  605. const id = f.cloudUrl || f.url || `${f.name}|${f.size}`;
  606. if (seenFiles.has(id)) return false;
  607. seenFiles.add(id);
  608. return true;
  609. })
  610. .map((b) => ({ key: b.key, file: b.file }));
  611. /*
  612. * live 判定与 `isTurnOpen` 同口径:容器正在 typing,或末条消息至今未超过静默窗口。
  613. * 群聊里某个成员可能先回完,所以按**块**判断而不是按回合。
  614. *
  615. * 🔴 typing 不能无限期作数(2026-11-09)。
  616. *
  617. * 实测:容器一轮结束后**不会**发 `m.typing:false`,`peerTyping` 一直停在 true。
  618. * 这时 `live` 恒为真 → 回合永远「输出中」、永远不会自动折叠
  619. * (用户实测:内容早已输出完,界面挂着「运行了 2 步 · 163s 输出中」)。
  620. *
  621. * 所以 typing 也受静默窗口约束:已经很久没有新内容,就不再信它。
  622. */
  623. const idleFor = now - src.updatedAt;
  624. /*
  625. * 🔴 typing 窗口收紧为 `quietMs`(2026-11-11 用户实测)。
  626. *
  627. * 原来是 `quietMs * 2`(50 秒):容器明明已经把正文输出完、也不再发新消息,
  628. * 界面却要继续挂 50 秒「输出中」,用户以为卡住了(截图:20s 那次读数,
  629. * 实际等了 56 秒才变「已完成」)。
  630. *
  631. * 容器结束后**不会发 `m.typing:false`**,所以 typing 迟早要过期;
  632. * 既然过期后由「静默窗口」接管(同样的 quietMs),就没必要给 typing 双倍宽限 ——
  633. * 两个窗口对齐后,正文一停、读数也就跟着停,不会多挂 25 秒。
  634. */
  635. const typingAlive = src.typing && idleFor < quietMs;
  636. /*
  637. * 等待超时收尾(2026-11-10,用户裁决保留):
  638. *
  639. * `awaitingFirstReply` 若恒为真 → `live` 永远 true → 界面永远挂着
  640. * 「已送达,等待回复…(253s)」,`isTurnTimedOut` 要求 `!live` 永远不成立,
  641. * 全局提示也就永远不弹。所以等待超过 `TURN_TIMEOUT_MS` 后不再算「还在等」,
  642. * 交给超时逻辑收尾 → 占位消失、全局提示出现。
  643. */
  644. const waitingTooLong =
  645. awaitingFirstReply && waitingSince > 0 && now - waitingSince >= TURN_TIMEOUT_MS;
  646. /*
  647. * 🔴 用户级超时(2026-11-11 口径定稿后必须对**所有**未结束回合生效)。
  648. *
  649. * 结束判据改成「只看容器信号」之后,`live` 会在容器不吭声时一直为真。
  650. * 如果只有「还没回第一条」的回合能超时,那么「回了一半、容器挂了」的回合
  651. * 会永远转圈 —— 必须有出口,否则是把「提前完成」换成了「永远转圈」。
  652. *
  653. * 这是**异常态**出口:页面层据此弹「容器无响应」提示,
  654. * 与「正常完成」在语义上分得清清楚楚。
  655. */
  656. const hardTimedOut =
  657. waitingSince > 0 && now - waitingSince >= TURN_TIMEOUT_MS;
  658. /*
  659. * 🔴 长任务宽限(2026-11-11 用户实测修复)。
  660. *
  661. * 用户看到「运行了 2 步 · Writing ... 9s · 已结束 · 无交付」,
  662. * 而容器其实还在跑。
  663. *
  664. * 根因:`idleFor` 用的是**最后一条 agent 消息**的时间,而容器跑长工具时
  665. * 恰恰不产生消息 —— 20~25 秒空档就足以让 `live` 转 false,
  666. * 于是「有过程步骤、但没正文」的块被判成 `progressOnly`(已结束)。
  667. *
  668. * 现在:**已有过程步骤**说明容器真的在干活,宽限到 `STALL_MS`(60 秒)。
  669. * 超过 60 秒仍无动静,就交给 `isTurnStalled` 的全局提示(「容器已停止响应」),
  670. * 两个信号同一常量、互补而不冲突。
  671. */
  672. const hasSteps = steps.length > 0;
  673. const graceMs = hasSteps ? Math.max(quietMs, STALL_MS) : quietMs;
  674. /*
  675. * 🔴 「先显示已完成、过很久正文才出来」(2026-11-11 用户实测第二大问题)。
  676. *
  677. * ## 现象
  678. *
  679. * 用户问天气 → 容器先回一句「我先查一下这三地的实时天气。」→ 然后跑工具、
  680. * 几十秒后才发真正的结果。第一条消息到达时静默窗口开始倒计时,宽限一过
  681. * 就被判成 `done`(「已完成」),用户看到「已完成」却没有答案。
  682. *
  683. * ## 为什么不能只靠时间窗口
  684. *
  685. * 容器是**分条发送**的:它可能在任何时刻停顿 60 秒以上(跑长工具、查网络)。
  686. * 从「有没有消息」推断「有没有干完」,本质上信息不足。
  687. *
  688. * ## 现在的判据(三档,优先级从高到低)
  689. *
  690. * ① 容器**明确宣告结束**(`turnEnded`:✅ reaction / typing=false)
  691. * → 立即收尾,这是唯一「确定干完了」的信号
  692. * ② 没有任何结束信号,但**本轮已经从用户提问算起跑完了整个超时窗口**
  693. * → 才允许判结束(兜底老容器,行为与改造前一致)
  694. * ③ 其余情况 → 保持「输出中」,不提前说完成
  695. *
  696. * 这样长任务不会再出现「先完成后输出」:只要容器没说结束,
  697. * 界面就一直如实显示在干活。
  698. */
  699. const silentLongEnough =
  700. waitingSince > 0 && now - waitingSince >= TURN_TIMEOUT_MS;
  701. /*
  702. * 🔴 `src.closed` 在有步骤时也要让路。
  703. *
  704. * `closed` 是聚合层在静默 `QUIET_MS` 后打的「这轮不再有新消息」标记 ——
  705. * 它恰恰会在容器跑长工具时打上(跑工具不产生消息)。
  706. * 若这里仍然 `!src.closed`,宽限就永远用不上,用户照样看到「已结束」。
  707. *
  708. * 所以:**没有步骤时**照旧尊重 closed(正常收尾);
  709. * **有步骤时**以时间为准(宽限到 STALL_MS)。
  710. */
  711. const closedBlocks = !hasSteps && src.closed;
  712. /*
  713. * 🔴 容器明确宣告结束(2026-11-11,`turnEnded`)—— **优先级高于一切时间窗口**。
  714. *
  715. * 实测(`scripts/.probe-typing.mjs`,lj-test):容器 16.8 秒就把正文发完并打了 ✅,
  716. * 但整轮 105 秒发不出一条结束信号,App 只能等 25 秒(有步骤时 60 秒)静默窗口,
  717. * 于是「20 秒的活」显示到 50 多秒还在「输出中」(用户实测截图)。
  718. *
  719. * 现在容器侧插件在 `post_llm_call` 发 `m.typing=false`,App 侧收到即停:
  720. * · 有结束信号 → `live` 立刻为 false,读数定格在末条消息时刻
  721. * · 无结束信号(未改造容器)→ 照旧走下面的静默窗口兜底,行为不变
  722. *
  723. * ⚠️ 只认「**确认结束**」,不认「没在打字」。容器在两条消息之间的空档也可能发
  724. * `typing=false`(本轮结束刷新),若把它当成结束,长工具跑一半就会被切断。
  725. * 所以信号必须带**轮次标识**,由 `turnEndedFor()` 按「是否晚于本块末条消息」判定。
  726. */
  727. const turnEnded = src.turnEnded === true;
  728. /*
  729. * 🔴 「还没收到结束信号」→ 不许判完成(2026-11-11)。
  730. *
  731. * 这是「先完成后输出」的根治点:容器分条发送时,第一条消息到达后
  732. * 静默窗口就开始了,宽限一过就显示「已完成」,而真正的答案还在后面。
  733. *
  734. * 判据:**有消息、没结束信号、整个超时窗口还没跑完** → 继续算「输出中」。
  735. * · 老容器(无信号):最多多挂到 180 秒超时,之后照常收尾 → 不会永远转
  736. * · 新容器:收到 ✅/typing=false 立刻收尾 → 不残留
  737. *
  738. * 注意这里**不覆盖** `turnEnded` 和 `waitingTooLong`:
  739. * 有结束信号就正常结束;超过 180 秒必须有出口,否则卡片永远停不下来。
  740. */
  741. /*
  742. * 🔴 结束以**容器信号**为准,不以时间猜(2026-11-11 用户裁决)。
  743. *
  744. * 用户原话:「为什么保持到 90s,应该保持到会话结束」。
  745. *
  746. * 他说得对。90 秒是我拍的兜底值,本质还是「用时间猜」——
  747. * 容器跑 2 分钟的长任务,到 90 秒照样会被标成「已结束」,
  748. * 这正是用户一直在抱怨的那个毛病。把 60 秒换成 90 秒,只是把问题推迟了 30 秒。
  749. *
  750. * 正确判据只有一条:**容器说结束(✅/❌ reaction)才算结束**。
  751. * 在那之前,只要这一轮**确实在干活**(有过程步骤),就一直算「输出中」。
  752. *
  753. * 唯一的出口是用户级超时 `TURN_TIMEOUT_MS`(180 秒):
  754. * · 它由页面层弹「容器无响应」提示,是**明确的异常态**,不是"正常完成"
  755. * · 没有它,容器真挂了界面会永远转圈
  756. *
  757. * ⚠️ 只在**有过程步骤**时启用:没有步骤的纯文本回合(容器只回一句话),
  758. * 仍按静默窗口收尾 —— 那种回合发完就是发完了,不该无限挂着。
  759. */
  760. /*
  761. * 🔴 「有步骤 + 没收到结束信号」→ 保持输出中,但**必须有上限**(2026-11-11)。
  762. *
  763. * ## 初版没有上限,导致历史会话永远转圈
  764. *
  765. * 初版写成 `hasSteps && !turnEnded && waitingSince > 0` —— 只要回合有工具步骤、
  766. * 又没收到过 ✅,就永远算 live。
  767. *
  768. * 但 **✅ reaction 是实时事件**:打开几天前的历史会话时,
  769. * 那些回合的 ✅ 早就发生过了、App 根本收不到(不是当前房间的实时流)。
  770. * 于是每一条历史回合都被判成「还在输出」——
  771. * 用户实测:「点开历史会话,显示 26208s 输出中,而且文字还在一个个蹦出来」。
  772. *
  773. * ## 现在的判据:**只有在「用户刚发出、且还在合理等待窗口内」才保持**
  774. *
  775. * 以用户提问时刻为锚点,超过 `LONG_TASK_HOLD_MS`(10 分钟)就不再保持 ——
  776. * · 真实长任务:实测容器跑过 3 分钟以上,10 分钟足够覆盖
  777. * · 历史会话:`waitingSince` 是几天前,立刻超出 → 正确判成已结束
  778. * · 容器真挂了:10 分钟后着陆,由 `isTurnStalled` 弹「无响应」提示,不会永远转
  779. *
  780. * 这个上限**小于** `TURN_TIMEOUT_MS`(5 分钟用户级超时)的语义边界:
  781. * 两者都只是「什么时候停止说在忙」,不改写已经发生的事实。
  782. */
  783. const LONG_TASK_HOLD_MS = 10 * 60_000;
  784. /*
  785. * 🔴 容器明确说「本会话空闲」→ **立即收尾,优先级高于保持逻辑**(2026-11-11)。
  786. *
  787. * 用户实测:右上角已经显示「在线」(容器报了 idle),卡片却还挂着「50s 输出中」。
  788. * 根因是 `agentIdle` 只把 `quietMs` 置 0,而 `heldOpenByNoSignal` 不看它 ——
  789. * 「有步骤 + 没 ✅」照样让块保持 live。
  790. *
  791. * 这不合理:**容器说空闲** 和 **✅ reaction** 是同一级别的事实信号
  792. * (都是容器自己宣布「这轮完了」),只是通道不同、到达时刻可能差几秒。
  793. * 任何一个到了都该收尾。
  794. */
  795. const settledBySession = agentIdle === true;
  796. const heldOpenByNoSignal =
  797. hasSteps &&
  798. !turnEnded &&
  799. !settledBySession &&
  800. waitingSince > 0 &&
  801. now - waitingSince < LONG_TASK_HOLD_MS;
  802. /*
  803. * 🔴 超时**不再强行改写状态**(2026-11-11 用户裁决「应该保持到会话结束」)。
  804. *
  805. * 上一版把 `hardTimedOut` 直接塞进 `live`,到点就把回合从「输出中」改成
  806. * 「已结束」—— 这跟「60 秒猜完成」是同一个错误,只是把猜的时间点挪后。
  807. * 用户要的是:**干活期间始终如实显示在干活**。
  808. *
  809. * 现在超时的作用只剩一个:**让页面层弹「容器无响应」提示**
  810. * (`isTurnTimedOut` 消费 `waitMs`),状态本身继续如实显示。
  811. * 用户看到「跑了 8 分钟 + 顺便弹个提示」比「跑到 3 分钟突然说完成」合理得多。
  812. */
  813. const live =
  814. !closedBlocks &&
  815. !(waitingTooLong && !hasSteps) &&
  816. !turnEnded &&
  817. !settledBySession &&
  818. (awaitingFirstReply || typingAlive || idleFor < graceMs || heldOpenByNoSignal);
  819. /*
  820. * 「还在等回复」——与 `live` **解耦**(2026-11-11 用户实测修复)。
  821. *
  822. * ## 为什么要独立于 live
  823. *
  824. * `live` 回答的是「是不是在流式输出」,它受 25 秒静默窗口约束
  825. * (`QUIET_MS`)—— 容器不回 typing 事件,不这样收尾回合就永远不结束。
  826. *
  827. * 但用户看到的是:发完消息,等 25 秒,界面**变成一片空白**
  828. * (段落被跳过、等待文案返回空串),然后一直空白到第 180 秒才弹超时提示。
  829. * 中间这 155 秒里没有任何「我在等」的指示(用户实测反馈)。
  830. *
  831. * `waiting` 回答的是「用户还在等第一口气」:只要还没超时,就该一直有提示。
  832. */
  833. /*
  834. * 「还在等第一口气」(2026-11-11)—— 与 `live` / `closed` 都解耦。
  835. *
  836. * 判据只看三件事:
  837. * ① 用户确实发过消息(`waitingSince > 0`)
  838. * ② 容器**一条 agent 消息都没回**(`src.messages` 为空)
  839. * ③ 还没到 180 秒超时
  840. *
  841. * 🔴 为什么不能复用 `awaitingFirstReply`:它在 `turnsFromDm` 里带了
  842. * `!t.closed`,而 `closed` 是聚合层在 25 秒静默后打的标记,远早于用户的
  843. * 超时判定。复用它会让「回合收尾 → live=false → waiting=false」同时成立,
  844. * 界面正好掉进那段纯空白(用户实测反馈的正是这个)。
  845. *
  846. * 🔴 为什么不能写成 `!src.closed`:`toBlockView` 拿不到 `t.closed`,
  847. * 而且上一条的理由说明这个标记本来就不该参与用户等待的语义。
  848. */
  849. const waiting =
  850. awaitingFirstReply &&
  851. src.messages.length === 0 &&
  852. waitingSince > 0 &&
  853. !waitingTooLong;
  854. /*
  855. * 用时读数(2026-11-10 合并口径):
  856. *
  857. * | 字段 | 锚点 | 用途 |
  858. * |---|---|---|
  859. * | `startAt` | **用户发出问话的时刻** | 头部与段头的实时读数(1→2→3… 每秒加) |
  860. * | `seconds` | 首条 → 末条 agent 消息 | 容器**真实处理耗时**,结束时定格,不跳变 |
  861. *
  862. * 进行中的读数由渲染层用每秒时钟现算(`elapsedSeconds()`),
  863. * 不再用「消息事件时间戳相减」——那样只会 5s → 18s → 30s 地跳。
  864. */
  865. /*
  866. * 🔴 `startAt` 必须在容器思考期间也有效(2026-11-18 修复「已处理 0s」)。
  867. *
  868. * ## 原来的问题
  869. *
  870. * 原写法 `waitingSince > 0 ? waitingSince : src.startedAt`:
  871. * `src.startedAt` 由 `turn-aggregator` 在**收到第一条 agent 消息时**才赋值
  872. * (新建回合时初始化为 0)。容器思考期间还没有任何 agent 消息,
  873. * 于是 `startedAt === 0` → `elapsedSeconds()` 直接 `return 0`
  874. * → 界面显示「已处理 **0s**」并一直不动(用户实测)。
  875. *
  876. * ## 现在的兜底顺序
  877. *
  878. * ① `waitingSince` —— 用户发问时刻(最准,含容器思考的空档)
  879. * ② `src.startedAt` —— 首条 agent 消息时刻
  880. * ③ 0 —— 交给调用方:`elapsedSeconds()` 见 0 返回 0,
  881. * 而模板已用 `turnSeconds() > 0` 控制是否显示,
  882. * 所以这里绝不会显示成「已处理 0s」。
  883. *
  884. * ⚠️ 不能用 `now` 兜底 —— `now` 每秒变,`startAt` 跟着变会导致读数
  885. * 永远停在 0(每秒都被重算成新起点)。
  886. */
  887. const startAt = waitingSince > 0 ? waitingSince : src.startedAt;
  888. return {
  889. key: src.key ?? src.agentId ?? 'agent',
  890. agentId: src.agentId,
  891. /** 容器真实处理耗时(首条 → 末条 agent 消息),结束才有意义 */
  892. seconds:
  893. src.startedAt > 0 && src.updatedAt >= src.startedAt
  894. ? Math.max(0, Math.round((src.updatedAt - src.startedAt) / 1000))
  895. : 0,
  896. /** 本块开始时刻(epoch ms,0 = 无锚点)—— 逐秒读数的锚点 */
  897. startAt,
  898. updatedAt: src.updatedAt,
  899. steps,
  900. body,
  901. files,
  902. live,
  903. turnEnded,
  904. waiting,
  905. empty: !live && !waiting && body.length === 0 && steps.length === 0,
  906. merged: mergeBodies([{ body }]),
  907. waitingSince,
  908. waitMs: waitingSince > 0 ? Math.max(0, now - waitingSince) : 0,
  909. };
  910. }
  911. /**
  912. * 由各块合成回合阶段。
  913. *
  914. * 🔴 2026-11-10:「已完成」必须真的代表**有东西交付给用户**。
  915. *
  916. * 原判据是「只要不是全空就算 done」,于是容器只回了一串内部进度
  917. * (`🐍 Running code…` + 一句日志)时,卡片照样标「已完成」,
  918. * 用户打开一看什么也没有(实测截图)。
  919. *
  920. * 现在区分三档:
  921. * · 有正文 或 有文件 → `done`(真的交付了)
  922. * · 只有过程步骤、没有正文也没有文件 → `progressOnly`(干了活,但没交付)
  923. * · 什么都没有 → `idle`
  924. */
  925. function phaseOf(blocks: TurnBlockView[], closed: boolean): TurnPhase {
  926. if (blocks.some((b) => b.live && (b.body.length > 0 || b.steps.length > 0))) return 'replying';
  927. if (blocks.some((b) => b.live)) return 'thinking';
  928. if (blocks.length === 0) return closed ? 'idle' : 'thinking';
  929. const delivered = blocks.some((b) => b.body.length > 0 || b.files.length > 0);
  930. if (delivered) return 'done';
  931. // 只剩过程步骤:做过事,但没有可交付的内容
  932. return blocks.some((b) => b.steps.length > 0) ? 'progressOnly' : 'idle';
  933. }
  934. /**
  935. * 一块的**当前**用时秒数(2026-11-10 用户要求:一秒一秒叠加)。
  936. *
  937. * | 状态 | 返回值 |
  938. * |---|---|
  939. * | 无锚点(`startAt <= 0`) | 0,不显示 |
  940. * | 已结束(`!live`) | 从用户发问到结束的总用时(定格) |
  941. * | 进行中 | `floor((now - startAt) / 1000)`,**逐秒递增** |
  942. *
  943. * 🔴 进行中必须用实时时钟现算。原来直接用结束时刻相减,
  944. * 只在容器发新事件那一跳才变,用户看到的是 5s → 18s → 30s 的跳变。
  945. *
  946. * 取整一律 `floor`:进行中与结束态用同一种口径,结束瞬间才不会倒退 1 秒。
  947. *
  948. * @param block 块视图
  949. * @param now 当前时间(组件每秒刷新一次的那个时钟)
  950. */
  951. export function elapsedSeconds(block: TurnBlockView, now: number): number {
  952. if (block.startAt <= 0) return 0;
  953. /*
  954. * 🔴 结束态与进行中必须**同口径**,否则读数会倒退(2026-11-11 用户实测)。
  955. *
  956. * 进行中显示 `now - startAt` —— 这是用户体感的等待时长,包含容器思考的空档。
  957. * 原来结束后切成 `updatedAt - startAt`(末条 agent 消息时刻),
  958. * 但 `updatedAt` 只到「最后一条 agent 消息」,比用户实际等的短:
  959. * 用户等了 56 秒,一结束读数瞬间掉回 20 秒,看起来像计时坏了。
  960. *
  961. * 🔴 2026-11-11 二次修正:有**结束信号**时定格在末条消息时刻。
  962. *
  963. * 容器侧插件现在会发 `m.typing=false`,所以「正文发完」到「界面收尾」之间
  964. * 不再有 25/60 秒的空转。此时若仍读到 `now`,末条消息之后到信号到达的那一两秒
  965. * 会被算进读数,与 `seconds`(容器真实处理耗时)对不上。
  966. * 有信号时用 `updatedAt`(末条消息),读数即为容器真实耗时,精确且不再倒退。
  967. *
  968. * 只有在**没有结束信号**(未改造的老容器)时,才保留「用户体感时长」口径 ——
  969. * 因为那种情况下收尾是猜的,读数取 `now` 才不会在判定结束前突然跳跃。
  970. */
  971. if (!block.live) {
  972. if (block.updatedAt <= block.startAt) return block.seconds;
  973. /*
  974. * 定格到「末条活动时刻」。`now` 只用来兜住时钟尚未推进的边界,
  975. * 不额外加宽限 —— 宽限值是拍脑袋的,会让读数与测试/实际都对不上。
  976. */
  977. const endAt = Math.min(now, block.updatedAt);
  978. return Math.max(0, Math.floor((endAt - block.startAt) / 1000));
  979. }
  980. return Math.max(0, Math.floor((now - block.startAt) / 1000));
  981. }
  982. /**
  983. * 等待中的占位文案(2026-11-09 用户裁决)。
  984. *
  985. * | 阶段 | 判据 | 文案 |
  986. * |---|---|---|
  987. * | 已发出,还没有任何输出 | `live` 且无内容 | 8 秒内「正在思考…」;之后「已送达,等待回复…(Ns)」 |
  988. * | 开始输出 | `live` 且有内容 | 「正在输出…(Ns)」 |
  989. * | 结束且全空 | 非 live 且 empty | **空**(不再显示「未响应」气泡) |
  990. *
  991. * 🔴 文案要**一直兜底到回复真的回来**,中途不能消失:
  992. * 容器回一轮要十几秒,界面空白会被理解成「发了没反应」。
  993. *
  994. * 🔴 2026-11-10 用户裁决:**超时不再在会话里留「未响应」气泡**。
  995. *
  996. * 原实现回合结束后恒显示一个「⊙ 未响应」的小气泡,永远留在消息流里,
  997. * 看起来像「每条都失败了」。改为:
  998. * · 会话内**完全移除**该占位(返回空串,段级判据同步不再渲染)
  999. * · 由页面层弹**全局提示**(可手动关闭、不自动消失),见 `useTurnTimeout()`
  1000. *
  1001. * @param waitMs 距用户发出消息已经过了多久
  1002. * @param hasOutput 是否已经开始输出内容
  1003. * @param live 是否仍在进行中
  1004. * @param empty 是否已结束且什么也没有
  1005. */
  1006. export function waitText(
  1007. waitMs: number,
  1008. hasOutput: boolean,
  1009. live: boolean,
  1010. empty: boolean,
  1011. /**
  1012. * 锚点时刻(epoch ms):用户发出这条问话的时刻(2026-11-11)。
  1013. *
  1014. * 传了就带上起始时刻,让用户知道「从几点开始等的」——
  1015. * 只显示「正在思考…」时,用户分不清是刚发出还是已经卡了五分钟,
  1016. * 也不知道该不该刷新。0 / 缺省 = 不显示时刻(保持旧行为,老调用点不受影响)。
  1017. */
  1018. startAt = 0,
  1019. ): string {
  1020. // 已结束:无论有没有内容,都不再留等待占位(超时提示交给全局 toast)
  1021. if (!live) return '';
  1022. const sec = Math.max(0, Math.round(waitMs / 1000));
  1023. const at = startAt > 0 ? `${fmtTime(startAt)} ` : '';
  1024. /*
  1025. * 🔴 已有输出 → **不再显示任何等待文案**(2026-11-13 用户裁决)。
  1026. *
  1027. * 原来这里返回「正在输出…(Ns)」,但它和卡片头的「已处理 Ns」
  1028. * 表达的是同一件事,而且**两个计时器起点不同**(本函数从用户发消息算,
  1029. * `card-running` 从首条 agent 消息算),同一屏出现两个对不上的秒数。
  1030. *
  1031. * 现在:有输出就把时间显示完全交给卡片头。
  1032. * 开局阶段(还没有任何输出)仍保留「正在思考…」「已送达,等待回复…」——
  1033. * 那是用户唯一的反馈,不能省。
  1034. */
  1035. if (hasOutput) return '';
  1036. if (waitMs < WAIT_HINT_MS) {
  1037. return at ? `已送达 ${at}· 正在思考…(${sec}s)` : '正在思考…';
  1038. }
  1039. return sec > 0
  1040. ? `${at ? `${at}已送达` : '已送达'},等待回复…(${sec}s)`
  1041. : '已送达,等待回复…';
  1042. }
  1043. /** 超过这个时长就明确告诉用户「发出了、在等」,不再只是「正在思考」 */
  1044. export const WAIT_HINT_MS = 8_000;
  1045. /**
  1046. * 判定「这一轮是否已经超时未响应」(2026-11-10)。
  1047. *
  1048. * 超时 = 用户已发出消息、但经过 `timeoutMs` 仍**没有任何 agent 输出**,且回合已结束。
  1049. * 页面据此弹全局提示(手动关闭)。
  1050. *
  1051. * @param waitMs 距用户发出消息的毫秒数
  1052. * @param hasOutput agent 是否已经有正文或步骤
  1053. * @param live 回合是否仍在进行
  1054. */
  1055. export function isTurnTimedOut(
  1056. waitMs: number,
  1057. hasOutput: boolean,
  1058. live: boolean,
  1059. timeoutMs = TURN_TIMEOUT_MS,
  1060. ): boolean {
  1061. return !live && !hasOutput && waitMs >= timeoutMs;
  1062. }
  1063. /**
  1064. * 判定「容器卡住了」(2026-11-11)。
  1065. *
  1066. * ## 与 `isTurnTimedOut` 的分工
  1067. *
  1068. * | 情况 | 判据 | 函数 |
  1069. * |---|---|---|
  1070. * | 发了之后**一个字都没回**,超过 3 分钟 | `!live && !hasOutput && wait >= 180s` | `isTurnTimedOut` |
  1071. * | 回了**一部分**就停住,不再有任何新增 | `hasOutput && 静止 >= 60s` | `isTurnStalled` |
  1072. *
  1073. * 🔴 为什么必须有第二个:容器常常先回一句「我先看一下这个文件」、
  1074. * 跑了两步工具,然后就再没有下文了(用户实测截图 09:51 之后一片空白)。
  1075. * 这时 `hasOutput === true`,`isTurnTimedOut` **永远返回 false** ——
  1076. * 界面停在「已结束」但没有任何提示,用户只能干等。
  1077. *
  1078. * 这里的「静止」用**最后一条消息到现在的时长**,不是用户发问时长:
  1079. * 容器跑长任务时应该一直在产生工具活动,持续 1 分钟毫无动静即为异常。
  1080. *
  1081. * @param idleMs 距本回合**最后一次** agent 活动的毫秒数
  1082. * @param hasOutput agent 是否已经有正文或步骤
  1083. * @param live 回合是否仍在进行(还在 live 说明 Quartz 静默窗口还没过)
  1084. */
  1085. export function isTurnStalled(
  1086. idleMs: number,
  1087. hasOutput: boolean,
  1088. live: boolean,
  1089. stallMs = STALL_MS,
  1090. ): boolean {
  1091. /*
  1092. * 🔴 2026-11-11 口径定稿后修正:**不再要求 `!live`**。
  1093. *
  1094. * 旧判据假设「live 说明还在动」,但现在 `live` 的语义变成了
  1095. * 「这一轮还没收到结束信号」—— 长任务卡死时它会一直为真,
  1096. * 于是「容器无响应」提示永远不会弹,用户只能干等。
  1097. *
  1098. * 正确的判据是**有没有新东西进来**:已经有输出、但连续 `stallMs` 毫无新增,
  1099. * 无论 live 与否都该提醒用户「可能卡住了」。
  1100. * 它只是**提示**,不改状态 —— 容器真有动静了,下一次渲染提示自然消失。
  1101. */
  1102. /* 一个字都没回的由 `isTurnTimedOut` 负责,两处不重叠 */
  1103. if (!hasOutput) return false;
  1104. return idleMs >= stallMs;
  1105. }
  1106. /* ------------------------------------------------------------------ */
  1107. /* 两种输入 → 统一的回合视图 */
  1108. /* ------------------------------------------------------------------ */
  1109. /**
  1110. * 群聊:`buildGroupTurns` 的结果 → 回合视图。
  1111. *
  1112. * 每个 `GroupBlock` 对应一个块;块顺序保持 `targets` 的声明顺序。
  1113. */
  1114. export function turnsFromGroup(
  1115. turns: GroupTurn[],
  1116. now: number,
  1117. quietMs = DEFAULT_QUIET_MS,
  1118. nameOf?: (agentId: string) => string,
  1119. ): AssistantTurn[] {
  1120. return turns.map((t) => {
  1121. const blocks = t.blocks.map((b) => {
  1122. const view = toBlockView(
  1123. {
  1124. agentId: b.agentId,
  1125. messages: b.messages,
  1126. startedAt: b.startedAt,
  1127. updatedAt: b.updatedAt,
  1128. typing: b.typing,
  1129. closed: b.closed,
  1130. },
  1131. now,
  1132. quietMs,
  1133. t.userMessage ? Date.parse(t.userMessage.ts) || 0 : 0,
  1134. /*
  1135. * 群聊里「这一块还没收到任何回复」= 等待中(2026-11-09,与单聊同口径)。
  1136. *
  1137. * 原来空块的 `updatedAt = 0` 会让 `idleFor` 极大,`live` 恒 false,
  1138. * 于是卡片是个空壳、没有文字 —— 用户看不到「谁在思考」(实测)。
  1139. */
  1140. b.messages.length === 0 && !b.closed,
  1141. );
  1142. const name = nameOf?.(b.agentId);
  1143. return name ? { ...view, agentName: name } : view;
  1144. });
  1145. const live = blocks.some((b) => b.live);
  1146. const merged = mergeBodies(blocks);
  1147. const collected = collectFiles(blocks);
  1148. return {
  1149. id: t.id,
  1150. userMessage: t.userMessage,
  1151. userFiles: t.userFiles ?? [],
  1152. blocks,
  1153. phase: phaseOf(blocks, t.closed),
  1154. // 与块级同口径:从用户发消息起算,live 时走当前时钟(时间戳取自原始块)
  1155. seconds: roundSeconds(t.blocks, now, live, t.userMessage ? Date.parse(t.userMessage.ts) || 0 : 0),
  1156. live,
  1157. closed: t.closed,
  1158. stepCount: blocks.reduce((n, b) => n + b.steps.length, 0),
  1159. fileCount: blocks.reduce((n, b) => n + b.files.length, 0),
  1160. missingFileCount: countMissingFiles(merged?.text ?? '', collected.length),
  1161. merged,
  1162. files: collectFiles(blocks),
  1163. };
  1164. });
  1165. }
  1166. /**
  1167. * 单聊:`buildTurns` 的结果 → 回合视图(固定 1 块)。
  1168. *
  1169. * @param typing 容器是否在 typing(容器大多不发,通常为 false)
  1170. * @param quietMs 「还在输出」的静默窗口,调用方传 `QUIET_MS`
  1171. * @param agentIdle 容器**明确上报**的空闲态。为 true 时忽略静默窗口直接收尾 ——
  1172. * 只有容器能宣布「我干完了」,比任何时间窗都准。
  1173. * @param turnEndedAfter 收到容器 `m.typing=false` 时,本会话最后一条 agent 消息的 id
  1174. * (null = 无信号)。只有「本块末条消息就是这个 id」才认它结束。
  1175. */
  1176. export function turnsFromDm(
  1177. turns: Turn[],
  1178. now: number,
  1179. typing: boolean,
  1180. quietMs = DEFAULT_QUIET_MS,
  1181. /**
  1182. * 容器**明确**上报的本会话空闲态(2026-11-11 统一方案)。
  1183. *
  1184. * 🔴 三态:`true` 明确空闲(直接收尾)/ `false` 明确在跑 / `undefined` 不知道。
  1185. * 初版是布尔且默认 `false`,但调用方传的 `agentIdle()` 曾把「没上报」
  1186. * 当成「空闲」,会误杀所有仍在跑的回合。现在三态分开,`undefined` 不参与判定。
  1187. */
  1188. agentIdle: boolean | undefined = undefined,
  1189. turnEndedAfter: string | null = null,
  1190. ): AssistantTurn[] {
  1191. return turns.map((t, turnIndex) => {
  1192. /*
  1193. * 🔴 这是不是**最后一个**回合?(2026-11-14 用户实测修复)
  1194. *
  1195. * 场景:任务执行中用户打断并发了新消息 → 旧回合永远等不到容器回复
  1196. * (容器去处理新消息了),于是旧卡片的「等待回复…」转圈**一直挂着**。
  1197. *
  1198. * 判据:后面还有别的用户提问,说明这条已经**过时**了,
  1199. * 不该再显示「等待回复」——用户已经在等更新的一轮。
  1200. */
  1201. const isLastTurn = turnIndex === turns.length - 1;
  1202. /*
  1203. * 🔴 拆成两个概念(2026-11-11):
  1204. *
  1205. * `awaitingFirstReply`(live 用):要求 `!t.closed` —— 回合静默收尾后
  1206. * `live` 该转 false,否则卡片永远不收尾(2026-11-10 的裁决,保留)。
  1207. *
  1208. * `pendingReply`(waiting 用):**不看 closed** —— `closed` 是聚合层在
  1209. * 25 秒静默后打的标记,远早于用户的 180 秒超时。若它也否认「还在等」,
  1210. * 界面从第 25 秒起就是一片空白,直到第 180 秒才弹提示(用户实测反馈)。
  1211. *
  1212. * 所以「有用户提问 + 容器一条都没回 + 没超时」就是还在等,与 closed 无关。
  1213. */
  1214. const hasUserAsk = !!t.userMessage;
  1215. const noAgentReply = t.blocks.length === 0;
  1216. const awaitingFirstReply = hasUserAsk && noAgentReply && !t.closed;
  1217. /*
  1218. * 「还在等第一口气」:必须同时是**最后一个**回合。
  1219. * 后面已经有更新的用户提问 → 这条已过时,转圈要停(见 `isLastTurn` 注释)。
  1220. */
  1221. const pendingReply = hasUserAsk && noAgentReply && isLastTurn;
  1222. const userAsk = t.userMessage ? Date.parse(t.userMessage.ts) || 0 : 0;
  1223. /*
  1224. * 🔴 按「轮次」拆块(2026-11-10)—— **收窄触发条件**(2026-11-11)。
  1225. *
  1226. * 拆轮原本是为了「图 + 文字各跑一轮时分别计时」。
  1227. * 但它按「相邻消息间隔 > 20 秒」(`ROUND_GAP_MS`)切分,而容器跑一个
  1228. * 长工具时**本来就不产生消息** —— 于是普通长任务被误切成 2~4 轮,
  1229. * 每轮各自判断 live,出现「有的块已完成、有的块还在跑」的混乱观感,
  1230. * 且所有块 key 都叫 `agent` 导致 NG0955。
  1231. *
  1232. * 现在只在**确实有多个用户提问**(图文各发一条)时才拆轮;
  1233. * 单次提问不论间隔多久都只出 1 块。
  1234. */
  1235. const userAskTimes = (t.userAskTimes ?? []).filter((a) => a > 0);
  1236. const askCount = userAskTimes.length;
  1237. /*
  1238. * 🔴 拆轮的真正前提:**每个提问之间都隔着新一轮对话**(2026-11-11 修正)。
  1239. *
  1240. * 用户实测(截图):发第一条后马上补发第二条「以 html 的形式发给我」,
  1241. * 界面出现「已送达等待回复 → 用户第二条 → 容器回复」的错乱顺序。
  1242. *
  1243. * 根因:原判据只看 `askCount > 1`,把「用户连发两条补充说明」也当成两轮,
  1244. * 于是第二条用户消息被挪到两个 agent 块之间渲染。
  1245. *
  1246. * 现在追加一条:**相邻两个提问之间必须有 agent 消息**
  1247. * (即提问 1 → 回复 → 提问 2),才认为真的是两轮。
  1248. * 连发两条(中间容器一句话都没说)视为同一轮,不拆。
  1249. */
  1250. const asks = [...userAskTimes].sort((a, b) => a - b);
  1251. const hasReplyBetweenAsks =
  1252. asks.length > 1 &&
  1253. asks.slice(1).every((at, i) => {
  1254. const prev = asks[i];
  1255. return (t.blocks ?? []).some((m) => {
  1256. const mt = Date.parse(m.ts) || 0;
  1257. return mt > prev && mt < at;
  1258. });
  1259. });
  1260. const canSplit =
  1261. askCount > 1 && hasReplyBetweenAsks && (t.rounds?.length ?? 0) > 1;
  1262. const rounds: Message[][] = canSplit
  1263. ? t.rounds!
  1264. : t.blocks.length > 0
  1265. ? [t.blocks]
  1266. : [];
  1267. /*
  1268. * 没有 agent 消息时也要有**一个**占位块,否则「已发出、等回复」的标志
  1269. * (`awaitingFirstReply`)无处挂载,卡片会整张消失。
  1270. */
  1271. const usedKeys = new Set<string>();
  1272. const blocks = rounds.length
  1273. ? rounds.map((msgs, idx) => {
  1274. const times = msgs.map((m) => Date.parse(m.ts) || 0).filter((n) => n > 0);
  1275. const first = times.length ? Math.min(...times) : 0;
  1276. const last = times.length ? Math.max(...times) : 0;
  1277. /*
  1278. * 本轮读秒锚点 = **不晚于本轮首条消息的最后一个用户提问时刻**。
  1279. * 图文被拆成两条时:图片那轮用图片的发出时刻,文字那轮用文字的发出时刻,
  1280. * 两轮读数各算各的,不会互相拉高,也不会在结束瞬间倒退。
  1281. */
  1282. const asks = (t.userAskTimes ?? []).filter((a) => a > 0 && (first === 0 || a <= first));
  1283. const startAt = asks.length ? Math.max(...asks) : first || userAsk;
  1284. /* key 必须唯一:多块共用 'agent' 会触发 NG0955 且让读数互相覆盖 */
  1285. const base = `agent:${msgs[0]?.id ?? `r${idx}`}`;
  1286. const key = usedKeys.has(base) ? `${base}:${idx}` : base;
  1287. usedKeys.add(key);
  1288. return toBlockView(
  1289. {
  1290. agentId: null,
  1291. key,
  1292. messages: msgs,
  1293. startedAt: first,
  1294. updatedAt: last,
  1295. typing,
  1296. closed: t.closed,
  1297. /*
  1298. * 结束信号按**消息 id** 认领(2026-11-11):
  1299. * 收到 `typing=false` 时记下的末条 agent 消息 id,必须正好是本块的末条。
  1300. * 不跨时钟比较(服务端 ts vs 本地时钟会差 1~2 秒),
  1301. * 也天然挡住了「上一轮的信号误伤这一轮」。
  1302. *
  1303. * 🔴 2026-11-14 补充:**不是最后一轮的回合,一律视为已结束**。
  1304. *
  1305. * 用户实测:容器早就回完了,卡片还在「已处理 Ns」继续计时,
  1306. * 而且此时发新消息也没有任何拦截(说明容器侧确实闲了)。
  1307. *
  1308. * 根因:`turnEndedAfter` 只保存**一个**值 —— 最近一次 ✅ 标注的
  1309. * 消息 id。多轮对话里它必然被后续轮次覆盖;更常见的是 ✅ 到达后
  1310. * 又有新消息涌入,`最后一条消息 id` 已经不等于记录时的那条,
  1311. * 严格相等判定永远失败 → 旧卡片永远转。
  1312. *
  1313. * 判据补一条:**后面还有更新的用户提问**(`!isLastTurn`)说明
  1314. * 这一轮早已过去,无论 ✅ 有没有对上,都不该再显示在跑。
  1315. */
  1316. turnEnded:
  1317. !isLastTurn ||
  1318. (turnEndedAfter != null &&
  1319. msgs.length > 0 &&
  1320. msgs[msgs.length - 1]?.id === turnEndedAfter),
  1321. },
  1322. now,
  1323. agentIdle === true ? 0 : quietMs,
  1324. startAt,
  1325. false,
  1326. agentIdle,
  1327. );
  1328. })
  1329. : [
  1330. toBlockView(
  1331. {
  1332. agentId: null,
  1333. key: 'agent:wait',
  1334. messages: [],
  1335. startedAt: 0,
  1336. updatedAt: 0,
  1337. typing,
  1338. closed: t.closed,
  1339. },
  1340. now,
  1341. agentIdle === true ? 0 : quietMs,
  1342. userAsk,
  1343. pendingReply,
  1344. ),
  1345. ];
  1346. const live = blocks.some((b) => b.live);
  1347. return {
  1348. id: t.id,
  1349. userMessage: t.userMessage,
  1350. priorAsks: t.priorAsks ?? [],
  1351. userFiles: t.userFiles ?? [],
  1352. blocks,
  1353. phase: phaseOf(blocks, t.closed),
  1354. /* 回合用时取最长的块(各轮并行跑,按最长那轮算体感) */
  1355. seconds: blocks.reduce((max, b) => Math.max(max, b.seconds), 0),
  1356. live,
  1357. closed: t.closed,
  1358. stepCount: blocks.reduce((n, b) => n + b.steps.length, 0),
  1359. fileCount: blocks.reduce((n, b) => n + b.files.length, 0),
  1360. missingFileCount: countMissingFiles(
  1361. mergeBodies(blocks)?.text ?? '',
  1362. collectFiles(blocks).length,
  1363. ),
  1364. /*
  1365. * 单聊的正文仍**合并成一份**(2026-11-07 用户要求「一整轮一张卡」)。
  1366. * 拆轮只为了分别计时与分别判定状态,不改变阅读形态。
  1367. */
  1368. merged: mergeBodies(blocks),
  1369. files: collectFiles(blocks),
  1370. };
  1371. });
  1372. }
  1373. /** 整轮的全部文件(跨容器聚合,宫格统一渲染) */
  1374. function collectFiles(blocks: TurnBlockView[]): { key: string; file: FileCard }[] {
  1375. const seen = new Set<string>();
  1376. const out: { key: string; file: FileCard }[] = [];
  1377. for (const b of blocks) {
  1378. for (const f of b.files) {
  1379. // 同名同大小的重复文件只出一张卡(多容器转发同一份时)
  1380. const sig = `${f.file.name}|${f.file.size ?? 0}|${f.file.url}`;
  1381. if (seen.has(sig)) continue;
  1382. seen.add(sig);
  1383. out.push(f);
  1384. }
  1385. }
  1386. return out;
  1387. }
  1388. /**
  1389. * 正文里声明了、但没拿到附件事件的文件数(2026-11-16 真机修复)。
  1390. *
  1391. * ## 背景
  1392. *
  1393. * 向容器 `agent-node-lj-test` 核实(2026-11-16),容器原话:
  1394. * 「我用 `MEDIA:` 标记。在正文里写 `MEDIA:/绝对路径`,由 Matrix 适配器解析后
  1395. * 以 m.file 附件事件发出,同时正文保留文本。」
  1396. * 「(多文件时)标记存在但适配器没有为它们生成对应的事件……实际只到了部分文件。」
  1397. *
  1398. * 于是出现「正文 3 条链接、卡片 2 张」且**毫无提示**。
  1399. *
  1400. * ## 只认明确的标记
  1401. *
  1402. * 只统计两种**确定是容器声明的文件**:
  1403. * ① `MEDIA:/path` 标记(容器的正式约定)
  1404. * ② 指向本项目云盘的链接(`s3.fmode.cn` / `file-cloud.fmode.cn`)
  1405. *
  1406. * 不做模糊匹配 —— 正文里随便一句 URL 不该被当成「文件丢失」。
  1407. * 正文里的裸路径(如 `/opt/data/work/x.html`)也不计入:容器发文件时
  1408. * 一定会写 MEDIA 标记或给出可下载链接,裸路径只是解释文字。
  1409. *
  1410. * ## 为什么要去重
  1411. *
  1412. * 同一个文件在正文里可能被提到多次(链接 + MEDIA 标记),
  1413. * 按「文件名」去重后再和卡片数比较,才能得到真实的差。
  1414. *
  1415. * @param text 整轮合并后的正文
  1416. * @param cardCount 实际渲染出的卡片数(已去重)
  1417. * @returns 缺失的文件数;0 表示正文声明数与卡片数吻合
  1418. */
  1419. function countMissingFiles(text: string, cardCount: number): number {
  1420. if (!text && cardCount === 0) return 0;
  1421. const declared = new Set<string>();
  1422. // ① MEDIA 标记:`MEDIA:xxx`(容器写的是 MEDIA:/绝对路径)
  1423. for (const match of text.matchAll(/MEDIA:\s*(\S+)/gi)) {
  1424. declared.add(basename(match[1]));
  1425. }
  1426. // ② 云盘链接:只认本项目域名,且取路径最后一段做文件名
  1427. for (const match of text.matchAll(
  1428. /https?:\/\/(?:s3|file-cloud)\.fmode\.cn\/[^\s)\]>'"]+/gi,
  1429. )) {
  1430. declared.add(basename(match[0]));
  1431. }
  1432. /*
  1433. * 🔴 剔除中间产物(2026-11-18)。
  1434. *
  1435. * 容器有时会把 `data.json` / `probe.txt` / `same.txt` 这类辅助文件也列进正文。
  1436. * 它们本来就不是交付物、也不会挂附件卡片,算进「缺失」会让提示一直误报
  1437. * (实测:「还有 4 个文件未收到」,其中 2 个是容器自测的探针文件)。
  1438. *
  1439. * 判据与 `artifact-sync.service.ts::isIntermediateName()` 保持同一套口径。
  1440. */
  1441. for (const name of declared) {
  1442. if (isPaidDeliverableGuess(name) === false) declared.delete(name);
  1443. }
  1444. // 正文里一个明确的文件都没声明 → 谈不上缺失(避免把纯文字回复误判)
  1445. if (declared.size === 0) return 0;
  1446. return Math.max(0, declared.size - cardCount);
  1447. }
  1448. /**
  1449. * 粗判「这个文件名像不像用户要的交付物」(2026-11-18)。
  1450. *
  1451. * ⚠️ 与 `artifact-sync.service.ts::isIntermediateName()` 是**镜像实现** ——
  1452. * 两个模块分属不同层(core/assistant-turn 与 core/artifact-sync),
  1453. * 为避免循环依赖没有直接 import。改判据时**两处都要改**。
  1454. */
  1455. function isPaidDeliverableGuess(fileName: string): boolean {
  1456. const n = (fileName || '').trim().toLowerCase();
  1457. if (!n) return false;
  1458. /* 去掉云盘前缀(`3-mwln7vrfjy-data.json` → `data.json`) */
  1459. /*
  1460. * 剥掉云盘存储名的序号前缀,兼容两种形态:
  1461. * `3-mwln7vrfjy-data.json` → `data.json`(数字-随机串-)
  1462. * `0-probe.txt` → `probe.txt`(数字-)
  1463. */
  1464. const clean = n.replace(/^\d+-([a-z0-9]{6,}-)?/, '');
  1465. /* 与 artifact-sync.service.ts::isIntermediateName 保持同一口径 */
  1466. const DATA_ONLY = /\.(json|yaml|yml|toml|ini|log|lock)$/;
  1467. if (DATA_ONLY.test(clean) && /^(data|tmp|temp|cache|intermediate|scratch|state)/.test(clean))
  1468. return false;
  1469. if (/^(build|gen|generate|make|run|test|probe)[-_a-z0-9]*\.(py|sh|js|ts|mjs|bat|ps1)$/.test(clean))
  1470. return false;
  1471. if (/^(draft|backup|bak|old|tmp)[-_.]/.test(clean)) return false;
  1472. if (/\.(bak|tmp|swp|orig)$/.test(clean)) return false;
  1473. if (/^(probe|same|wtest)([-_.]|\d)/.test(clean)) return false;
  1474. return true;
  1475. }
  1476. /** 取路径/URL 最后一段(去掉 query 与 hash),用于按文件名去重比对 */
  1477. function basename(pathOrUrl: string): string {
  1478. const noQuery = pathOrUrl.split(/[?#]/)[0];
  1479. const seg = noQuery.split('/').filter(Boolean).pop() ?? noQuery;
  1480. try {
  1481. return decodeURIComponent(seg).toLowerCase();
  1482. } catch {
  1483. return seg.toLowerCase();
  1484. }
  1485. }
  1486. /**
  1487. * 把整轮所有块的正文拼成一份。
  1488. *
  1489. * 块之间用空行分隔(Markdown 段落边界),保持可读;
  1490. * key 取首条正文消息 id,**不随内容增长而变** —— 否则流式时模板会重建 DOM。
  1491. */
  1492. function mergeBodies(blocks: { body: TurnBodyBlock[] }[]): TurnMergedBody | null {
  1493. const parts: string[] = [];
  1494. let first: Message | null = null;
  1495. let last: Message | null = null;
  1496. for (const b of blocks) {
  1497. for (const part of b.body) {
  1498. if (part.kind !== 'text') continue;
  1499. const t = (part.message.text ?? '').trim();
  1500. if (!t) continue;
  1501. parts.push(t);
  1502. if (!first) first = part.message;
  1503. last = part.message;
  1504. }
  1505. }
  1506. if (!first || !last) return null;
  1507. return { key: first.id, text: parts.join('\n\n'), message: last };
  1508. }
  1509. /** 回合耗时:首条 agent 消息到末条(各块取并集,避免多块重复计算) */
  1510. /**
  1511. * 回合级耗时(群聊汇总用)。
  1512. *
  1513. * 🔴 必须与块级 `toBlockView` 同一口径(2026-11-10),否则同一张卡片上
  1514. * 段头写一个数、汇总写另一个数,用户会以为界面在乱跳。
  1515. *
  1516. * 口径:从**用户发出消息**起算。live 时取当前时钟(稳定递增),
  1517. * 结束后冻结在最晚的一条消息时间。多块之间取「最大结束 - 用户消息」,
  1518. * 也就是「这一轮最忙的那个成员干完为止」。
  1519. */
  1520. function roundSeconds(
  1521. blocks: { startedAt: number; updatedAt: number }[],
  1522. now: number,
  1523. live: boolean,
  1524. waitingSince: number,
  1525. ): number {
  1526. const starts = blocks.map((b) => b.startedAt).filter((n) => n > 0);
  1527. const ends = blocks.map((b) => b.updatedAt).filter((n) => n > 0);
  1528. // 锚点优先取用户消息,没有才回落到最早的一条 agent 消息
  1529. const anchor = waitingSince > 0 ? waitingSince : starts.length ? Math.min(...starts) : 0;
  1530. if (anchor <= 0) return 0;
  1531. const endAt = live ? now : ends.length ? Math.max(...ends) : 0;
  1532. if (endAt < anchor) return 0;
  1533. return Math.max(0, Math.round((endAt - anchor) / 1000));
  1534. }
  1535. /** 便捷入口:判断回合里是否有该文件(避免模板里重复过滤) */
  1536. export function hasFiles(t: AssistantTurn): boolean {
  1537. return t.fileCount > 0;
  1538. }